Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "FPSCR", ")", ";", "Reserved", ".", "set", "(", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "FramePtr", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "Reserved", ".", "set", "(", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasVFP3", "(", ")", "||", "STI", ".", "hasD16", "(", ")", ")", "{", "assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "16", ";", "++", "i", ")", "Reserved", ".", "set", "(", "ARM", "::", "D16", "+", "i", ")", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "RC", "->", "begin", "(", ")", ",", "E", "=", "RC", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "for", "(", "MCSubRegIterator", "SI", "(", "*", "I", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "0", "16", "ARM::D16", "ARM::GPRPairRegClass" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isReassocProfitable", "(", "SelectionDAG", "&", "DAG", ",", "SDValue", "N0", ",", "SDValue", "N1", ")", "const", "{", "if", "(", "!", "N0", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "unsigned", "IID", "=", "getIntrinsicID", "(", "N1", ".", "getNode", "(", ")", ")", ";", "if", "(", "IID", "==", "Intrinsic", "::", "aarch64_neon_umull", "||", "N1", ".", "getOpcode", "(", ")", "==", "AArch64ISD", "::", "UMULL", "||", "IID", "==", "Intrinsic", "::", "aarch64_neon_smull", "||", "N1", ".", "getOpcode", "(", ")", "==", "AArch64ISD", "::", "SMULL", ")", "return", "N0", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ";", "return", "true", ";", "}", "</s>" ]

[ "Control", "the", "following", "reassociation", "of", "operands", ":", "(", "op", "(", "op", "x", ",", "c1", ")", ",", "y", ")", "-", ">", "(", "op", "(", "op", "x", ",", "y", ")", ",", "c1", ")", "where", "N0", "is", "(", "op", "x", ",", "c1", ")", "and", "N1", "is", "y", "." ]

[ "AArch64", "AArch64", "Intrinsic::aarch64_neon_umull", "AArch64ISD::UMULL", "Intrinsic::aarch64_neon_smull", "AArch64ISD::SMULL", "ISD::ADD" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "int", "insvdi_rshift_rlwimi_p", "(", "rtx", "sizeop", ",", "rtx", "startop", ",", "rtx", "shiftop", ")", "{", "if", "(", "INTVAL", "(", "startop", ")", "<", "64", "&&", "INTVAL", "(", "startop", ")", ">", "32", "&&", "(", "INTVAL", "(", "sizeop", ")", "+", "INTVAL", "(", "startop", ")", "<", "64", ")", "&&", "(", "INTVAL", "(", "sizeop", ")", "+", "INTVAL", "(", "startop", ")", ">", "33", ")", "&&", "(", "INTVAL", "(", "sizeop", ")", "+", "INTVAL", "(", "startop", ")", "+", "INTVAL", "(", "shiftop", ")", "<", "96", ")", "&&", "(", "INTVAL", "(", "sizeop", ")", "+", "INTVAL", "(", "startop", ")", "+", "INTVAL", "(", "shiftop", ")", ">=", "64", ")", "&&", "(", "64", "-", "(", "INTVAL", "(", "shiftop", ")", "&", "63", ")", ")", ">=", "INTVAL", "(", "sizeop", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "operands", "will", "generate", "a", "valid", "arguments", "to", "rlwimiinstruction", "for", "insert", "with", "right", "shift", "in", "64-bit", "mode", ".", "The", "mask", "maynot", "start", "on", "the", "first", "bit", "or", "stop", "on", "the", "last", "bit", "because", "wrap-aroundeffects", "of", "instruction", "do", "not", "correspond", "to", "semantics", "of", "RTL", "insn", "." ]

[ "rs6000", "64", "32", "64", "33", "96", "64", "64", "63", "1", "0" ]

[]

[ "<s>", "virtual", "MVT", "getShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Returns", "the", "type", "for", "the", "shift", "amount", "of", "a", "shift", "opcode", "." ]

[ "XNCM", "MVT::i8" ]

[]

[ "<s>", "bool", "msp430_use_f5_series_hwmult", "(", "void", ")", "{", "static", "const", "char", "*", "cached_match", "=", "NULL", ";", "static", "bool", "cached_result", ";", "if", "(", "msp430_hwmult_type", "==", "F5SERIES", ")", "return", "true", ";", "if", "(", "target_mcu", "==", "NULL", "||", "msp430_hwmult_type", "!=", "AUTO", ")", "return", "false", ";", "if", "(", "target_mcu", "==", "cached_match", ")", "return", "cached_result", ";", "cached_match", "=", "target_mcu", ";", "if", "(", "strncasecmp", "(", "target_mcu", ",", "\"msp430f5\"", ",", "8", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "if", "(", "strncasecmp", "(", "target_mcu", ",", "\"msp430fr5\"", ",", "9", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "if", "(", "strncasecmp", "(", "target_mcu", ",", "\"msp430f6\"", ",", "8", ")", "==", "0", ")", "return", "cached_result", "=", "true", ";", "int", "i", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "target_mcu", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "cached_result", "=", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", "==", "8", ";", "return", "cached_result", "=", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "current", "MCU", "supports", "an", "F5xxx", "series", "hardware", "multiper", "." ]

[ "msp430", "\"msp430f5\"", "8", "0", "\"msp430fr5\"", "9", "0", "\"msp430f6\"", "8", "0", "0", "8" ]

[]

[ "<s>", "unsigned", "int", "fr30_compute_frame_size", "(", "int", "from_reg", ",", "int", "to_reg", ")", "{", "int", "regno", ";", "unsigned", "int", "return_value", ";", "unsigned", "int", "var_size", ";", "unsigned", "int", "args_size", ";", "unsigned", "int", "pretend_size", ";", "unsigned", "int", "reg_size", ";", "unsigned", "int", "gmask", ";", "var_size", "=", "WORD_ALIGN", "(", "get_frame_size", "(", ")", ")", ";", "args_size", "=", "WORD_ALIGN", "(", "current_function_outgoing_args_size", ")", ";", "pretend_size", "=", "current_function_pretend_args_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "current_frame_info", ".", "save_fp", "=", "MUST_SAVE_FRAME_POINTER", ";", "current_frame_info", ".", "save_rp", "=", "MUST_SAVE_RETURN_POINTER", ";", "reg_size", "+=", "(", "current_frame_info", ".", "save_fp", "+", "current_frame_info", ".", "save_rp", ")", "*", "UNITS_PER_WORD", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_size", "=", "reg_size", ";", "current_frame_info", ".", "frame_size", "=", "args_size", "+", "var_size", ";", "current_frame_info", ".", "total_size", "=", "args_size", "+", "var_size", "+", "reg_size", "+", "pretend_size", ";", "current_frame_info", ".", "gmask", "=", "gmask", ";", "current_frame_info", ".", "initialised", "=", "reload_completed", ";", "return_value", "=", "0", ";", "if", "(", "to_reg", "==", "STACK_POINTER_REGNUM", ")", "return_value", "+=", "args_size", "+", "var_size", ";", "if", "(", "from_reg", "==", "ARG_POINTER_REGNUM", ")", "return_value", "+=", "reg_size", ";", "return", "return_value", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "offset", "between", "FROM_REG", "and", "TO_REG", "for", "the", "current", "function", ".", "As", "a", "side", "effect", "it", "fills", "in", "the", "current_frame_info", "structure", ",", "if", "the", "data", "is", "available", "." ]

[ "fr30", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "V_SUB_F64", ":", "{", "unsigned", "DestReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_F64", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_RegisterStorePseudo", ":", "{", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "SI_RegisterStore", ")", ",", "Reg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "R600", "SI", "SI", "SI", "0", "0", "1", "1", "2", "0", "0", "SI", "SI", "0" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "!", "X86ScalarizeAMX", ")", "return", "false", ";", "TargetMachine", "*", "TM", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "if", "(", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeNone", ")", "&&", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "return", "false", ";", "auto", "*", "DTWP", "=", "getAnalysisIfAvailable", "<", "DominatorTreeWrapperPass", ">", "(", ")", ";", "auto", "*", "DT", "=", "DTWP", "?", "&", "DTWP", "->", "getDomTree", "(", ")", ":", "nullptr", ";", "auto", "*", "LIWP", "=", "getAnalysisIfAvailable", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "auto", "*", "LI", "=", "LIWP", "?", "&", "LIWP", "->", "getLoopInfo", "(", ")", ":", "nullptr", ";", "DomTreeUpdater", "DTU", "(", "DT", ",", "DomTreeUpdater", "::", "UpdateStrategy", "::", "Lazy", ")", ";", "X86LowerAMXIntrinsics", "LAT", "(", "F", ",", "DTU", ",", "LI", ")", ";", "return", "LAT", ".", "visit", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "DisablePPCPreinc", ")", "return", "false", ";", "bool", "isLoad", "=", "true", ";", "SDValue", "Ptr", ";", "EVT", "VT", ";", "unsigned", "Alignment", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Alignment", "=", "LD", "->", "getAlignment", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Alignment", "=", "ST", "->", "getAlignment", "(", ")", ";", "isLoad", "=", "false", ";", "}", "else", "return", "false", ";", "if", "(", "isLoad", "&&", "usePartialVectorLoads", "(", "N", ",", "Subtarget", ")", ")", "{", "return", "false", ";", "}", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "!", "Subtarget", ".", "hasQPX", "(", ")", "||", "(", "VT", "!=", "MVT", "::", "v4f64", "&&", "VT", "!=", "MVT", "::", "v4f32", ")", ")", "{", "return", "false", ";", "}", "else", "if", "(", "SelectAddressRegRegOnly", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ")", ")", "{", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "}", "if", "(", "SelectAddressRegReg", "(", "Ptr", ",", "Base", ",", "Offset", ",", "DAG", ")", ")", "{", "bool", "Swap", "=", "false", ";", "if", "(", "isa", "<", "FrameIndexSDNode", ">", "(", "Base", ")", "||", "isa", "<", "RegisterSDNode", ">", "(", "Base", ")", ")", "Swap", "=", "true", ";", "else", "if", "(", "!", "isLoad", ")", "{", "SDValue", "Val", "=", "cast", "<", "StoreSDNode", ">", "(", "N", ")", "->", "getValue", "(", ")", ";", "if", "(", "Val", "==", "Base", "||", "Base", ".", "getNode", "(", ")", "->", "isPredecessorOf", "(", "Val", ".", "getNode", "(", ")", ")", ")", "Swap", "=", "true", ";", "}", "if", "(", "Swap", ")", "std", "::", "swap", "(", "Base", ",", "Offset", ")", ";", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", ")", "{", "if", "(", "!", "SelectAddressRegImm", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ",", "None", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "Alignment", "<", "4", ")", "return", "false", ";", "if", "(", "!", "SelectAddressRegImm", "(", "Ptr", ",", "Offset", ",", "Base", ",", "DAG", ",", "Align", "(", "4", ")", ")", ")", "return", "false", ";", "}", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "if", "(", "LD", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", "&&", "LD", "->", "getMemoryVT", "(", ")", "==", "MVT", "::", "i32", "&&", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Offset", ")", ")", "return", "false", ";", "}", "AM", "=", "ISD", "::", "PRE_INC", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "PowerPC", "PPC", "ISD::MemIndexedMode", "PPC", "MVT::v4f64", "MVT::v4f32", "ISD::PRE_INC", "ISD::PRE_INC", "MVT::i64", "4", "4", "0", "MVT::i64", "MVT::i32", "ISD::SEXTLOAD", "ISD::PRE_INC" ]

[]

[ "<s>", "SDNode", "*", "MBlazeDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "MBlaze", "::", "ADDIK", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "}", "case", "MBlazeISD", "::", "JmpLink", ":", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "{", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Callee", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "R20Reg", "=", "CurDAG", "->", "getRegister", "(", "MBlaze", "::", "R20", ",", "MVT", "::", "i32", ")", ";", "SDValue", "InFlag", "(", "0", ",", "0", ")", ";", "if", "(", "(", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "||", "(", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", ")", "{", "SDValue", "GPReg", "=", "CurDAG", "->", "getRegister", "(", "MBlaze", "::", "R15", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "Callee", ",", "GPReg", ",", "Chain", "}", ";", "SDValue", "Load", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "MBlaze", "::", "LW", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ",", "Ops", ",", "3", ")", ",", "0", ")", ";", "Chain", "=", "Load", ".", "getValue", "(", "1", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R20Reg", ",", "Load", ",", "InFlag", ")", ";", "}", "else", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "dl", ",", "R20Reg", ",", "Callee", ",", "InFlag", ")", ";", "SDNode", "*", "ResNode", "=", "CurDAG", "->", "getMachineNode", "(", "MBlaze", "::", "BRLID", ",", "dl", ",", "MVT", "::", "Other", ",", "MVT", "::", "Glue", ",", "R20Reg", ",", "Chain", ")", ";", "Chain", "=", "SDValue", "(", "ResNode", ",", "0", ")", ";", "InFlag", "=", "SDValue", "(", "ResNode", ",", "1", ")", ";", "ReplaceUses", "(", "SDValue", "(", "Node", ",", "0", ")", ",", "Chain", ")", ";", "ReplaceUses", "(", "SDValue", "(", "Node", ",", "1", ")", ",", "InFlag", ")", ";", "return", "ResNode", ";", "}", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "ISD::GLOBAL_OFFSET_TABLE", "ISD::FrameIndex", "0", "MVT::i32", "0", "MBlaze::ADDIK", "MBlazeISD::JmpLink", "0", "1", "MBlaze::R20", "MVT::i32", "0", "0", "MBlaze::R15", "MVT::i32", "MBlaze::LW", "MVT::i32", "MVT::Other", "3", "0", "1", "MBlaze::BRLID", "MVT::Other", "MVT::Glue", "0", "1", "0", "1", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "XCore" ]

[]

[ "<s>", "static", "bool", "aarch64_vect_float_const_representable_p", "(", "rtx", "x", ")", "{", "rtx", "elt", ";", "return", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_VECTOR_FLOAT", "&&", "const_vec_duplicate_p", "(", "x", ",", "&", "elt", ")", "&&", "aarch64_float_const_representable_p", "(", "elt", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "x", "is", "a", "uniform", "vector", "of", "floating-point", "constants", ",", "and", "the", "constant", "can", "be", "represented", "in", "quarter-precision", "form", ".", "Note", ",", "as", "aarch64_float_const_representable", "rejects", "both", "+0.0", "and", "-0.0", ",", "we", "will", "also", "reject", "+0.0", "and", "-0.0", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "SystemZAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ";", "++", "I", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "SystemZOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "llvm_unreachable", "(", "\"Unexpected match type\"", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "SystemZ", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"Unexpected match type\"" ]

[]

[ "<s>", "static", "int", "ix86_mode_entry", "(", "int", "entity", ")", "{", "switch", "(", "entity", ")", "{", "case", "X86_DIRFLAG", ":", "return", "ix86_dirflag_mode_entry", "(", ")", ";", "case", "AVX_U128", ":", "return", "ix86_avx_u128_mode_entry", "(", ")", ";", "case", "I387_TRUNC", ":", "case", "I387_FLOOR", ":", "case", "I387_CEIL", ":", "return", "I387_CW_ANY", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "mode", "that", "ENTITY", "is", "assumed", "to", "be", "switched", "to", "at", "function", "entry", "." ]

[ "i386" ]

[]

[ "<s>", "static", "unsigned", "parse_field", "(", "const", "std", "::", "string", "&", "field", ")", "{", "const", "char", "*", "rest", "=", "strchr", "(", "field", ".", "c_str", "(", ")", ",", "':'", ")", ";", "if", "(", "rest", "==", "NULL", ")", "return", "-", "1", ";", "char", "*", "after", ";", "unsigned", "fint", "=", "strtol", "(", "rest", "+", "1", ",", "&", "after", ",", "16", ")", ";", "if", "(", "after", "==", "rest", "+", "1", ")", "return", "-", "1", ";", "return", "fint", ";", "}", "</s>" ]

[ "Returns", "the", "hex", "integer", "that", "is", "after", "'", ":", "'", "for", "the", "FIELD", ".", "Returns", "-1", "is", "returned", "if", "there", "was", "problem", "parsing", "the", "integer", "." ]

[ "aarch64", "1", "1", "16", "1", "1" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "small_data_operand", "(", "x", ",", "GET_MODE", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"@%s(%s)\"", ",", "SMALL_DATA_RELOC", ",", "reg_names", "[", "SMALL_DATA_REG", "]", ")", ";", "else", "gcc_assert", "(", "!", "TARGET_TOC", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "if", "(", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "0", ")", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "1", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"(%s)\"", ",", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "fprintf", "(", "file", ",", "\"lo16(\"", ")", ";", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "&&", "CONSTANT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "output_addr_const", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "}", "else", "if", "(", "toc_relative_expr_p", "(", "x", ",", "false", ",", "&", "tocrel_base_oac", ",", "&", "tocrel_offset_oac", ")", ")", "{", "output_addr_const", "(", "file", ",", "CONST_CAST_RTX", "(", "tocrel_base_oac", ")", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "fprintf", "(", "file", ",", "\"@l(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "x", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "XVECEXP", "(", "tocrel_base_oac", ",", "0", ",", "1", ")", ")", "]", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

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

[ "rs6000", "\"0(%s)\"", "\"@%s(%s)\"", "0", "1", "0", "0", "\"%s,%s\"", "1", "0", "\"%s,%s\"", "0", "1", "0", "1", "\"(%s)\"", "1", "0", "0", "1", "\"lo16(\"", "1", "\")(%s)\"", "0", "0", "1", "1", "\"@l(%s)\"", "0", "\"@l(%s)\"", "0", "\"(%s)\"", "0", "1" ]

[]

[ "<s>", "static", "inline", "void", "aarch64_add_sp", "(", "rtx", "temp1", ",", "rtx", "temp2", ",", "poly_int64", "delta", ",", "bool", "emit_move_imm", ")", "{", "aarch64_add_offset", "(", "Pmode", ",", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "delta", ",", "temp1", ",", "temp2", ",", "true", ",", "emit_move_imm", ")", ";", "}", "</s>" ]

[ "Add", "DELTA", "to", "the", "stack", "pointer", ",", "marking", "the", "instructions", "frame-related", ".", "TEMP1", "is", "available", "as", "a", "temporary", "if", "nonnull", ".", "EMIT_MOVE_IMM", "is", "false", "if", "TEMP1", "already", "contains", "abs", "(", "DELTA", ")", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "requiresUniformRegister", "(", "MachineFunction", "&", "MF", ",", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_if_break", ":", "return", "true", ";", "}", "}", "if", "(", "const", "ExtractValueInst", "*", "ExtValue", "=", "dyn_cast", "<", "ExtractValueInst", ">", "(", "V", ")", ")", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "ExtValue", "->", "getOperand", "(", "0", ")", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_if", ":", "case", "Intrinsic", "::", "amdgcn_else", ":", "{", "ArrayRef", "<", "unsigned", ">", "Indices", "=", "ExtValue", "->", "getIndices", "(", ")", ";", "if", "(", "Indices", ".", "size", "(", ")", "==", "1", "&&", "Indices", "[", "0", "]", "==", "1", ")", "{", "return", "true", ";", "}", "}", "}", "}", "}", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "isa", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ")", "{", "const", "SIRegisterInfo", "*", "SIRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "ImmutableCallSite", "CS", "(", "CI", ")", ";", "TargetLowering", "::", "AsmOperandInfoVector", "TargetConstraints", "=", "ParseConstraints", "(", "MF", ".", "getDataLayout", "(", ")", ",", "Subtarget", "->", "getRegisterInfo", "(", ")", ",", "CS", ")", ";", "for", "(", "auto", "&", "TC", ":", "TargetConstraints", ")", "{", "if", "(", "TC", ".", "Type", "==", "InlineAsm", "::", "isOutput", ")", "{", "ComputeConstraintToUse", "(", "TC", ",", "SDValue", "(", ")", ")", ";", "unsigned", "AssignedReg", ";", "const", "TargetRegisterClass", "*", "RC", ";", "std", "::", "tie", "(", "AssignedReg", ",", "RC", ")", "=", "getRegForInlineAsmConstraint", "(", "SIRI", ",", "TC", ".", "ConstraintCode", ",", "TC", ".", "ConstraintVT", ")", ";", "if", "(", "RC", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "AssignedReg", "!=", "0", "&&", "SIRI", "->", "isSGPRReg", "(", "MRI", ",", "AssignedReg", ")", ")", "return", "true", ";", "else", "if", "(", "SIRI", "->", "isSGPRClass", "(", "RC", ")", ")", "return", "true", ";", "}", "}", "}", "}", "}", "SetVector", "<", "const", "Value", "*", ">", "Visited", ";", "return", "hasIfBreakUser", "(", "V", ",", "Visited", ")", ";", "}", "</s>" ]

[ "Allows", "target", "to", "decide", "about", "the", "register", "class", "of", "the", "specific", "value", "that", "is", "live", "outside", "the", "defining", "block", "." ]

[ "AMDGPU", "SI", "Intrinsic::amdgcn_if_break", "0", "Intrinsic::amdgcn_if", "Intrinsic::amdgcn_else", "1", "0", "1", "SI", "SI", "SI", "0", "SI", "SI" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "Z80TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Z80", "::", "GR8RegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "Z80", "::", "GR16RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0u", ",", "static_cast", "<", "const", "TargetRegisterClass", "*", ">", "(", "0", ")", ")", ";", "case", "'c'", ":", "if", "(", "VT", "==", "MVT", "::", "i16", ")", "return", "std", "::", "make_pair", "(", "(", "unsigned", ")", "Z80", "::", "BC", ",", "&", "Z80", "::", "GR16RegClass", ")", ";", "assert", "(", "\"Unexpected type.\"", ")", ";", "}", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", ";", "R", "=", "parseRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "second", ")", "return", "R", ";", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "1", "0", "MVT::i8", "0U", "Z80::GR8RegClass", "MVT::i16", "0U", "Z80::GR16RegClass", "0u", "0", "MVT::i16", "Z80::BC", "Z80::GR16RegClass", "\"Unexpected type.\"" ]

[]

[ "<s>", "static", "void", "visium_add_queued_cfa_restore_notes", "(", "rtx", "insn", ")", "{", "rtx", "last", ";", "if", "(", "!", "cfa_restores", ")", "return", ";", "for", "(", "last", "=", "cfa_restores", ";", "XEXP", "(", "last", ",", "1", ")", ";", "last", "=", "XEXP", "(", "last", ",", "1", ")", ")", ";", "XEXP", "(", "last", ",", "1", ")", "=", "REG_NOTES", "(", "insn", ")", ";", "REG_NOTES", "(", "insn", ")", "=", "cfa_restores", ";", "cfa_restores", "=", "NULL_RTX", ";", "}", "</s>" ]

[ "Add", "queued", "REG_CFA_RESTORE", "notes", "to", "INSN", ",", "if", "any", "." ]

[ "visium", "1", "1", "1" ]

[]

[ "<s>", "static", "enum", "aarch64_parse_opt_result", "aarch64_parse_arch", "(", "const", "char", "*", "to_parse", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ")", "{", "char", "*", "ext", ";", "const", "struct", "processor", "*", "arch", ";", "char", "*", "str", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "to_parse", ")", "+", "1", ")", ";", "size_t", "len", ";", "strcpy", "(", "str", ",", "to_parse", ")", ";", "ext", "=", "strchr", "(", "str", ",", "'+'", ")", ";", "if", "(", "ext", "!=", "NULL", ")", "len", "=", "ext", "-", "str", ";", "else", "len", "=", "strlen", "(", "str", ")", ";", "if", "(", "len", "==", "0", ")", "return", "AARCH64_PARSE_MISSING_ARG", ";", "for", "(", "arch", "=", "all_architectures", ";", "arch", "->", "name", "!=", "NULL", ";", "arch", "++", ")", "{", "if", "(", "strlen", "(", "arch", "->", "name", ")", "==", "len", "&&", "strncmp", "(", "arch", "->", "name", ",", "str", ",", "len", ")", "==", "0", ")", "{", "unsigned", "long", "isa_temp", "=", "arch", "->", "flags", ";", "if", "(", "ext", "!=", "NULL", ")", "{", "enum", "aarch64_parse_opt_result", "ext_res", "=", "aarch64_parse_extension", "(", "ext", ",", "&", "isa_temp", ")", ";", "if", "(", "ext_res", "!=", "AARCH64_PARSE_OK", ")", "return", "ext_res", ";", "}", "*", "res", "=", "arch", ";", "*", "isa_flags", "=", "isa_temp", ";", "return", "AARCH64_PARSE_OK", ";", "}", "}", "return", "AARCH64_PARSE_INVALID_ARG", ";", "}", "</s>" ]

[ "Parse", "the", "TO_PARSE", "string", "and", "put", "the", "architecture", "struct", "that", "it", "selects", "into", "RES", "and", "the", "architectural", "features", "into", "ISA_FLAGS", ".", "Return", "an", "aarch64_parse_opt_result", "describing", "the", "parse", "result", ".", "If", "there", "is", "an", "error", "parsing", ",", "RES", "and", "ISA_FLAGS", "are", "left", "unchanged", "." ]

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

[]

[ "<s>", "static", "reg_class_t", "arc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "cl", ",", "machine_mode", ",", "secondary_reload_info", "*", ")", "{", "if", "(", "cl", "==", "DOUBLE_REGS", ")", "return", "GENERAL_REGS", ";", "if", "(", "(", "cl", "==", "LPCOUNT_REG", "||", "cl", "==", "WRITABLE_CORE_REGS", ")", "&&", "in_p", "&&", "MEM_P", "(", "x", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "For", "ARC", "base", "register", "+", "offset", "addressing", ",", "the", "validity", "of", "the", "address", "is", "mode-dependent", "for", "most", "of", "the", "offset", "range", ",", "as", "the", "offset", "can", "be", "scaled", "by", "the", "access", "size", ".", "We", "do", "n't", "expose", "these", "as", "mode-dependent", "addresses", "in", "the", "mode_dependent_address_p", "target", "hook", ",", "because", "that", "would", "disable", "lots", "of", "optimizations", ",", "and", "most", "uses", "of", "these", "addresses", "are", "for", "32", "or", "64", "bit", "accesses", "anyways", ",", "which", "are", "fine", ".", "However", ",", "that", "leaves", "some", "addresses", "for", "8", "/", "16", "bit", "values", "not", "properly", "reloaded", "by", "the", "generic", "code", ",", "which", "is", "why", "we", "have", "to", "schedule", "secondary", "reloads", "for", "these", "." ]

[ "arc" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RetLocs", ";", "CCState", "RetCCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RetLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "isRV64", "(", ")", ")", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_RISCV64", ")", ";", "else", "RetCCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_RISCV32", ")", ";", "SDValue", "Glue", ";", "if", "(", "RetLocs", ".", "empty", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "RISCVISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", ";", "RetOps", ".", "push_back", "(", "Chain", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "RetLocs", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "CCValAssign", "&", "VA", "=", "RetLocs", "[", "I", "]", ";", "SDValue", "RetValue", "=", "OutVals", "[", "I", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "RetValue", "=", "convertValVTToLocVT", "(", "DAG", ",", "DL", ",", "VA", ",", "RetValue", ")", ";", "unsigned", "Reg", "=", "VA", ".", "getLocReg", "(", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "RetValue", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "Reg", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "return", "DAG", ".", "getNode", "(", "RISCVISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "XCoreTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "XCore", "::", "GRRegsRegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "1", "0", "0U", "XCore::GRRegsRegisterClass" ]

[]

[ "<s>", "static", "bool", "r10k_uncached_address_p", "(", "unsigned", "HOST_WIDE_INT", "address", ")", "{", "unsigned", "HOST_WIDE_INT", "upper", ";", "if", "(", "address", "+", "0x60000000", "<", "0x20000000", ")", "return", "true", ";", "if", "(", "Pmode", "==", "DImode", ")", "{", "upper", "=", "(", "address", ">>", "40", ")", "&", "0xf9ffff", ";", "if", "(", "upper", "==", "0x900000", "||", "upper", "==", "0xb80000", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDRESS", "is", "known", "to", "be", "an", "uncached", "address", "on", "R10K", "systems", "." ]

[ "mips", "0x60000000", "0x20000000", "40", "0xf9ffff", "0x900000", "0xb80000" ]

[]

[ "<s>", "void", "expand_fusion_p9_store", "(", "rtx", "*", "operands", ")", "{", "rtx", "tmp_reg", "=", "operands", "[", "0", "]", ";", "rtx", "addis_value", "=", "operands", "[", "1", "]", ";", "rtx", "orig_mem", "=", "operands", "[", "2", "]", ";", "rtx", "src", "=", "operands", "[", "3", "]", ";", "rtx", "new_addr", ",", "new_mem", ",", "orig_addr", ",", "offset", ",", "set", ",", "clobber", ",", "insn", ",", "new_src", ";", "enum", "rtx_code", "plus_or_lo_sum", ";", "machine_mode", "target_mode", "=", "GET_MODE", "(", "orig_mem", ")", ";", "machine_mode", "ptr_mode", "=", "Pmode", ";", "gcc_assert", "(", "MEM_P", "(", "orig_mem", ")", ")", ";", "orig_addr", "=", "XEXP", "(", "orig_mem", ",", "0", ")", ";", "plus_or_lo_sum", "=", "GET_CODE", "(", "orig_addr", ")", ";", "gcc_assert", "(", "plus_or_lo_sum", "==", "PLUS", "||", "plus_or_lo_sum", "==", "LO_SUM", ")", ";", "offset", "=", "XEXP", "(", "orig_addr", ",", "1", ")", ";", "new_addr", "=", "gen_rtx_fmt_ee", "(", "plus_or_lo_sum", ",", "ptr_mode", ",", "addis_value", ",", "offset", ")", ";", "new_mem", "=", "replace_equiv_address_nv", "(", "orig_mem", ",", "new_addr", ",", "false", ")", ";", "new_src", "=", "gen_rtx_UNSPEC", "(", "target_mode", ",", "gen_rtvec", "(", "1", ",", "src", ")", ",", "UNSPEC_FUSION_P9", ")", ";", "set", "=", "gen_rtx_SET", "(", "new_mem", ",", "new_src", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "tmp_reg", ")", ";", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", ";", "}", "</s>" ]

[ "During", "the", "peephole2", "pass", ",", "adjust", "and", "expand", "the", "insns", "for", "an", "extended", "fusion", "store", "sequence", ".", "The", "operands", "are", ":", "operands", "[", "0", "]", "register", "set", "with", "addis", "operands", "[", "1", "]", "value", "set", "via", "addis", "operands", "[", "2", "]", "target", "D-form", "memory", "being", "stored", "to", "operands", "[", "3", "]", "register", "being", "stored", "This", "is", "similar", "to", "the", "fusion", "introduced", "with", "power8", ",", "except", "it", "scales", "to", "both", "loads/stores", "and", "does", "not", "require", "the", "result", "register", "to", "be", "the", "same", "as", "the", "base", "register", ".", "At", "the", "moment", ",", "we", "only", "do", "this", "if", "register", "set", "with", "addis", "is", "dead", "." ]

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

[]

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

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "int", "loongarch_load_store_insns", "(", "rtx", "mem", ",", "rtx_insn", "*", "insn", ")", "{", "machine_mode", "mode", ";", "bool", "might_split_p", ";", "rtx", "set", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "might_split_p", "=", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ";", "if", "(", "might_split_p", ")", "{", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "loongarch_split_move_insn_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "set", ")", ")", ")", "might_split_p", "=", "false", ";", "}", "return", "loongarch_address_insns", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "mode", ",", "might_split_p", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "implement", "INSN", ",", "given", "that", "it", "loads", "from", "or", "stores", "to", "MEM", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "static", "unsigned", "rs6000_add_stmt_cost", "(", "void", "*", "data", ",", "int", "count", ",", "enum", "vect_cost_for_stmt", "kind", ",", "struct", "_stmt_vec_info", "*", "stmt_info", ",", "int", "misalign", ",", "enum", "vect_cost_model_location", "where", ")", "{", "rs6000_cost_data", "*", "cost_data", "=", "(", "rs6000_cost_data", "*", ")", "data", ";", "unsigned", "retval", "=", "0", ";", "if", "(", "flag_vect_cost_model", ")", "{", "tree", "vectype", "=", "stmt_info", "?", "stmt_vectype", "(", "stmt_info", ")", ":", "NULL_TREE", ";", "int", "stmt_cost", "=", "rs6000_builtin_vectorization_cost", "(", "kind", ",", "vectype", ",", "misalign", ")", ";", "if", "(", "where", "==", "vect_body", "&&", "stmt_info", "&&", "stmt_in_inner_loop_p", "(", "stmt_info", ")", ")", "count", "*=", "50", ";", "retval", "=", "(", "unsigned", ")", "(", "count", "*", "stmt_cost", ")", ";", "cost_data", "->", "cost", "[", "where", "]", "+=", "retval", ";", "}", "return", "retval", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.add_stmt_cost", "." ]

[ "rs6000", "0", "50" ]

[]

[ "<s>", "AArch64GenInstrInfo", "::", "MachineOutlinerInstrType", "AArch64InstrInfo", "::", "getOutliningType", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "getLOHRelated", "(", ")", ".", "count", "(", "&", "MI", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", "||", "MI", ".", "isIndirectDebugValue", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Invisible", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "succ_empty", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "readsRegister", "(", "AArch64", "::", "W30", ",", "&", "getRegisterInfo", "(", ")", ")", "||", "MI", ".", "modifiesRegister", "(", "AArch64", "::", "W30", ",", "&", "getRegisterInfo", "(", ")", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MOP", ".", "isCPI", "(", ")", "||", "MOP", ".", "isJTI", "(", ")", "||", "MOP", ".", "isCFIIndex", "(", ")", "||", "MOP", ".", "isFI", "(", ")", "||", "MOP", ".", "isTargetIndex", "(", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "if", "(", "MOP", ".", "isReg", "(", ")", "&&", "getRegisterInfo", "(", ")", ".", "regsOverlap", "(", "MOP", ".", "getReg", "(", ")", ",", "AArch64", "::", "LR", ")", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "AArch64", "::", "SP", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "AArch64", "::", "SP", ",", "&", "RI", ")", ")", "{", "if", "(", "MI", ".", "mayLoadOrStore", "(", ")", ")", "{", "unsigned", "Base", ";", "int64_t", "Offset", ";", "unsigned", "DummyWidth", ";", "if", "(", "!", "getMemOpBaseRegImmOfsWidth", "(", "MI", ",", "Base", ",", "Offset", ",", "DummyWidth", ",", "&", "RI", ")", "||", "Base", "!=", "AArch64", "::", "SP", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "int64_t", "MinOffset", ",", "MaxOffset", ";", "unsigned", "DummyScale", ";", "getMemOpInfo", "(", "MI", ".", "getOpcode", "(", ")", ",", "DummyScale", ",", "DummyWidth", ",", "MinOffset", ",", "MaxOffset", ")", ";", "if", "(", "Offset", "+", "16", "<", "MinOffset", "||", "Offset", "+", "16", ">", "MaxOffset", ")", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "return", "MachineOutlinerInstrType", "::", "Illegal", ";", "}", "return", "MachineOutlinerInstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::W30", "AArch64::W30", "AArch64::LR", "AArch64::SP", "AArch64::SP", "AArch64::SP", "16", "16" ]

[]

[ "<s>", "MCSection", "*", "DLXTargetObjectFile", "::", "getSectionForConstant", "(", "const", "DataLayout", "&", "DL", ",", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ",", "unsigned", "&", "Align", ")", "const", "{", "if", "(", "isConstantInSmallSection", "(", "DL", ",", "C", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "getSectionForConstant", "(", "DL", ",", "Kind", ",", "C", ",", "Align", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "Function", "*", "AMDGPUIntrinsicInfo", "::", "getDeclaration", "(", "Module", "*", "M", ",", "unsigned", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "NumTys", ")", "const", "{", "return", "getDeclaration", "(", "M", ",", "IntrID", ",", "makeArrayRef", "(", "Tys", ",", "NumTys", ")", ")", ";", "}", "</s>" ]

[ "Create", "or", "insert", "an", "LLVM", "Function", "declaration", "for", "an", "intrinsic", ",", "and", "return", "it", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "rtx", "m32c_libcall_value", "(", "enum", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "DFmode", ")", "{", "rtx", "rv", ";", "rv", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "4", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R0_REGNO", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "1", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R1_REGNO", ")", ",", "GEN_INT", "(", "2", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "2", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R2_REGNO", ")", ",", "GEN_INT", "(", "4", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "3", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "HImode", ",", "R3_REGNO", ")", ",", "GEN_INT", "(", "6", ")", ")", ";", "return", "rv", ";", "}", "if", "(", "TARGET_A24", "&&", "GET_MODE_SIZE", "(", "mode", ")", ">", "2", ")", "{", "rtx", "rv", ";", "rv", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "1", ")", ")", ";", "XVECEXP", "(", "rv", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "mode", ",", "R0_REGNO", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "return", "rv", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "2", ")", "return", "gen_rtx_REG", "(", "mode", ",", "MEM0_REGNO", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "R0_REGNO", ")", ";", "}", "</s>" ]

[ "Implements", "LIBCALL_VALUE", ".", "Most", "values", "are", "returned", "in", "$", "r0", ",", "or", "some", "combination", "of", "registers", "starting", "there", "(", "r2r0", "for", "longs", ",", "r3r1r2r0", "for", "long", "long", ",", "r3r2r1r0", "for", "doubles", ")", ",", "except", "that", "that", "ABI", "currently", "does", "n't", "work", "because", "it", "ends", "up", "using", "all", "available", "general", "registers", "and", "gcc", "often", "ca", "n't", "compile", "it", ".", "So", ",", "instead", ",", "we", "return", "anything", "bigger", "than", "16", "bits", "in", "``", "mem0", "''", "(", "effectively", ",", "a", "memory", "location", ")", "." ]

[ "m32c", "4", "0", "0", "0", "0", "1", "2", "0", "2", "4", "0", "3", "6", "2", "1", "0", "0", "0", "2" ]

[]

[ "<s>", "const_iterator", "begin", "(", ")", "const", "{", "return", "Seq", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "bpf_init_builtins", "(", "void", ")", "{", "tree", "ullt", "=", "long_long_unsigned_type_node", ";", "def_builtin", "(", "\"__builtin_bpf_load_byte\"", ",", "BPF_BUILTIN_LOAD_BYTE", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_bpf_load_half\"", ",", "BPF_BUILTIN_LOAD_HALF", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_bpf_load_word\"", ",", "BPF_BUILTIN_LOAD_WORD", ",", "build_function_type_list", "(", "ullt", ",", "ullt", ",", "0", ")", ")", ";", "def_builtin", "(", "\"__builtin_preserve_access_index\"", ",", "BPF_BUILTIN_PRESERVE_ACCESS_INDEX", ",", "build_function_type_list", "(", "ptr_type_node", ",", "ptr_type_node", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Define", "machine-specific", "built-in", "functions", "." ]

[ "bpf", "\"__builtin_bpf_load_byte\"", "0", "\"__builtin_bpf_load_half\"", "0", "\"__builtin_bpf_load_word\"", "0", "\"__builtin_preserve_access_index\"", "0" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_MSP430", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Outs", "[", "i", "]", ".", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "MSP430ISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MSP430ISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::OutputArg", "16", "MSP430", "0", "0", "\"Can only return in registers!\"", "1", "MSP430ISD::RET_FLAG", "MVT::Other", "MSP430ISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "Created", ")", "const", "{", "AttributeList", "Attr", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ";", "if", "(", "isIntDivCheap", "(", "N", "->", "getValueType", "(", "0", ")", ",", "Attr", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "assert", "(", "(", "Divisor", ".", "isPowerOf2", "(", ")", "||", "(", "-", "Divisor", ")", ".", "isPowerOf2", "(", ")", ")", "&&", "\"Unexpected divisor!\"", ")", ";", "if", "(", "!", "Subtarget", ".", "hasCMov", "(", ")", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i32", "&&", "!", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "VT", "==", "MVT", "::", "i64", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Lg2", "=", "Divisor", ".", "countTrailingZeros", "(", ")", ";", "if", "(", "Lg2", "==", "1", ")", "return", "SDValue", "(", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Pow2MinusOne", "=", "DAG", ".", "getConstant", "(", "(", "1ULL", "<<", "Lg2", ")", "-", "1", ",", "DL", ",", "VT", ")", ";", "SDValue", "Cmp", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "MVT", "::", "i8", ",", "N0", ",", "Zero", ",", "ISD", "::", "SETLT", ")", ";", "SDValue", "Add", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "DL", ",", "VT", ",", "N0", ",", "Pow2MinusOne", ")", ";", "SDValue", "CMov", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "DL", ",", "VT", ",", "Cmp", ",", "Add", ",", "N0", ")", ";", "Created", ".", "push_back", "(", "Cmp", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "Add", ".", "getNode", "(", ")", ")", ";", "Created", ".", "push_back", "(", "CMov", ".", "getNode", "(", ")", ")", ";", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "DL", ",", "VT", ",", "CMov", ",", "DAG", ".", "getConstant", "(", "Lg2", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "if", "(", "Divisor", ".", "isNonNegative", "(", ")", ")", "return", "SRA", ";", "Created", ".", "push_back", "(", "SRA", ".", "getNode", "(", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "VT", ",", "Zero", ",", "SRA", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "X86", "X86", "0", "0", "\"Unexpected divisor!\"", "0", "MVT::i16", "MVT::i32", "MVT::i64", "1", "0", "0", "1ULL", "1", "MVT::i8", "ISD::SETLT", "ISD::ADD", "ISD::SELECT", "ISD::SRA", "MVT::i64", "ISD::SUB" ]

[]

[ "<s>", "unsigned", "SNESMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

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

[]

[ "<s>", "static", "bool", "rs6000_is_opaque_type", "(", "tree", "type", ")", "{", "return", "(", "type", "==", "opaque_V2SI_type_node", "||", "type", "==", "opaque_V2SF_type_node", "||", "type", "==", "opaque_p_V2SI_type_node", "||", "type", "==", "opaque_V4SI_type_node", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "is", "a", "SPE", "or", "AltiVec", "opaque", "type", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "new", "CoalesceFeaturesAndStripAtomics", "(", "&", "getWebAssemblyTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyAddMissingPrototypes", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerGlobalDtors", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "if", "(", "!", "EnableEmException", "&&", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "None", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "EnableEmException", "||", "EnableEmSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", "EnableEmException", ",", "EnableEmSjLj", ")", ")", ";", "addPass", "(", "createIndirectBrExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AsmPrinter", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "WebAssembly" ]

[]

[ "<s>", "rtx", "frv_find_base_term", "(", "rtx", "x", ")", "{", "struct", "frv_unspec", "unspec", ";", "if", "(", "frv_const_unspec_p", "(", "x", ",", "&", "unspec", ")", "&&", "frv_small_data_reloc_p", "(", "unspec", ".", "symbol", ",", "unspec", ".", "reloc", ")", ")", "return", "plus_constant", "(", "unspec", ".", "symbol", ",", "unspec", ".", "offset", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Implement", "FIND_BASE_TERM", ".", "See", "whether", "ORIG_X", "represents", "#", "gprel12", "(", "foo", ")", "or", "#", "gotoff12", "(", "foo", ")", "for", "some", "small", "data", "symbol", "foo", ".", "If", "so", ",", "return", "foo", ",", "otherwise", "return", "ORIG_X", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "preservesZeroValueInReg", "(", "const", "MachineInstr", "*", "MI", ",", "const", "Register", "NullValueReg", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "MI", "->", "modifiesRegister", "(", "NullValueReg", ",", "TRI", ")", ")", "return", "true", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "SHR64ri", ":", "case", "X86", "::", "SHR32ri", ":", "case", "X86", "::", "SHL64ri", ":", "case", "X86", "::", "SHL32ri", ":", "assert", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isUse", "(", ")", "&&", "\"expected for shift opcode!\"", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "NullValueReg", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "NullValueReg", ";", "case", "X86", "::", "MOV32rr", ":", "return", "llvm", "::", "all_of", "(", "MI", "->", "operands", "(", ")", ",", "[", "&", "]", "(", "const", "MachineOperand", "&", "MO", ")", "{", "return", "TRI", "->", "isSubRegisterEq", "(", "NullValueReg", ",", "MO", ".", "getReg", "(", ")", ")", ";", "}", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"Should be handled above!\"", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "MI", "'s", "Def", "is", "NullValueReg", ",", "and", "the", "MI", "does", "not", "change", "the", "Zero", "value", "." ]

[ "X86", "X86", "X86::SHR64ri", "X86::SHR32ri", "X86::SHL64ri", "X86::SHL32ri", "0", "1", "\"expected for shift opcode!\"", "0", "1", "X86::MOV32rr", "\"Should be handled above!\"" ]

[]

[ "<s>", "Register", "P2RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "P2", "::", "PTRA", ";", "}", "</s>" ]

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

[ "P2", "P2", "P2::PTRA" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "PPCInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "PPCII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_PLT", ",", "\"ppc-plt\"", "}", ",", "{", "MO_PIC_FLAG", ",", "\"ppc-pic\"", "}", ",", "{", "MO_PCREL_FLAG", ",", "\"ppc-pcrel\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "\"ppc-plt\"", "\"ppc-pic\"", "\"ppc-pcrel\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetSubtargetInfo", "*", "STI", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getMcpu", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "MCPU_440", "||", "Directive", "==", "PPC", "::", "MCPU_A2", "||", "Directive", "==", "PPC", "::", "MCPU_E500mc", "||", "Directive", "==", "PPC", "::", "MCPU_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::MCPU_440", "PPC::MCPU_A2", "PPC::MCPU_E500mc", "PPC::MCPU_E5500", "PPC" ]

[]

[ "<s>", "MVT", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", ",", "EVT", "LHSTy", ")", "const", "override", "{", "return", "MVT", "::", "i8", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "MCS51", "MVT::i8" ]

[]

[ "<s>", "static", "enum", "dispatch_group", "get_mem_group", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_memory", "memory", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "<", "0", ")", "return", "disp_no_group", ";", "memory", "=", "get_attr_memory", "(", "insn", ")", ";", "if", "(", "memory", "==", "MEMORY_STORE", ")", "return", "disp_store", ";", "if", "(", "memory", "==", "MEMORY_LOAD", ")", "return", "disp_load", ";", "if", "(", "memory", "==", "MEMORY_BOTH", ")", "return", "disp_load_store", ";", "return", "disp_no_group", ";", "}", "</s>" ]

[ "Get", "dispatch", "group", "of", "insn", "." ]

[ "i386", "0" ]

[]

[ "<s>", "void", "neon_split_vcombine", "(", "rtx", "operands", "[", "3", "]", ")", "{", "unsigned", "int", "dest", "=", "REGNO", "(", "operands", "[", "0", "]", ")", ";", "unsigned", "int", "src1", "=", "REGNO", "(", "operands", "[", "1", "]", ")", ";", "unsigned", "int", "src2", "=", "REGNO", "(", "operands", "[", "2", "]", ")", ";", "machine_mode", "halfmode", "=", "GET_MODE", "(", "operands", "[", "1", "]", ")", ";", "unsigned", "int", "halfregs", "=", "HARD_REGNO_NREGS", "(", "src1", ",", "halfmode", ")", ";", "rtx", "destlo", ",", "desthi", ";", "if", "(", "src1", "==", "dest", "&&", "src2", "==", "dest", "+", "halfregs", ")", "{", "emit_note", "(", "NOTE_INSN_DELETED", ")", ";", "return", ";", "}", "destlo", "=", "gen_rtx_REG_offset", "(", "operands", "[", "0", "]", ",", "halfmode", ",", "dest", ",", "0", ")", ";", "desthi", "=", "gen_rtx_REG_offset", "(", "operands", "[", "0", "]", ",", "halfmode", ",", "dest", "+", "halfregs", ",", "GET_MODE_SIZE", "(", "halfmode", ")", ")", ";", "if", "(", "src2", "==", "dest", "&&", "src1", "==", "dest", "+", "halfregs", ")", "{", "rtx", "x", "=", "gen_rtx_SET", "(", "destlo", ",", "operands", "[", "1", "]", ")", ";", "rtx", "y", "=", "gen_rtx_SET", "(", "desthi", ",", "operands", "[", "2", "]", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "x", ",", "y", ")", ")", ")", ";", "return", ";", "}", "if", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "2", "]", ",", "destlo", ")", ")", "{", "if", "(", "src1", "!=", "dest", ")", "emit_move_insn", "(", "destlo", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "src2", "!=", "dest", "+", "halfregs", ")", "emit_move_insn", "(", "desthi", ",", "operands", "[", "2", "]", ")", ";", "}", "else", "{", "if", "(", "src2", "!=", "dest", "+", "halfregs", ")", "emit_move_insn", "(", "desthi", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "src1", "!=", "dest", ")", "emit_move_insn", "(", "destlo", ",", "operands", "[", "1", "]", ")", ";", "}", "}", "</s>" ]

[ "Split", "operands", "into", "moves", "from", "op", "[", "1", "]", "+", "op", "[", "2", "]", "into", "op", "[", "0", "]", "." ]

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

[]

[ "<s>", "void", "EmitInstruction", "(", "uint32_t", "Val", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "EmitByte", "(", "Val", "&", "0xff", ",", "OS", ")", ";", "Val", ">>=", "8", ";", "}", "}", "</s>" ]

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

[ "AArch64", "0", "4", "0xff", "8" ]

[]

[ "<s>", "const", "char", "*", "output_reload_inhi", "(", "rtx", "*", "op", ",", "rtx", "clobber_reg", ",", "int", "*", "plen", ")", "{", "output_reload_in_const", "(", "op", ",", "clobber_reg", ",", "plen", ",", "false", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Reload", "the", "constant", "OP", "[", "1", "]", "into", "the", "HI", "register", "OP", "[", "0", "]", ".", "CLOBBER_REG", "is", "a", "QI", "clobber", "reg", "needed", "to", "move", "vast", "majority", "of", "consts", "into", "a", "NO_LD_REGS", "register", ".", "If", "CLOBBER_REG", "is", "NULL_RTX", "we", "either", "do", "n't", "need", "a", "clobber", "reg", "or", "have", "to", "cook", "one", "up", ".", "PLEN", "==", "NULL", ":", "Output", "instructions", ".", "PLEN", "!", "=", "NULL", ":", "Output", "nothing", ".", "Set", "*", "PLEN", "to", "number", "of", "words", "occupied", "by", "the", "insns", "printed", ".", "Return", "``", "''", "." ]

[ "avr", "\"\"" ]

[]

[ "<s>", "void", "LC3InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "LC3", "::", "STR", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "LC3", "LC3", "LC3::STR", "0" ]

[]

[ "<s>", "MachineInstr", "*", "X86InstrInfo", "::", "optimizeLoadInstr", "(", "MachineInstr", "&", "MI", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "unsigned", "&", "FoldAsLoadDefReg", ",", "MachineInstr", "*", "&", "DefMI", ")", "const", "{", "DefMI", "=", "MRI", "->", "getVRegDef", "(", "FoldAsLoadDefReg", ")", ";", "assert", "(", "DefMI", ")", ";", "bool", "SawStore", "=", "false", ";", "if", "(", "!", "DefMI", "->", "isSafeToMove", "(", "nullptr", ",", "SawStore", ")", ")", "return", "nullptr", ";", "SmallVector", "<", "unsigned", ",", "1", ">", "SrcOperandIds", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "FoldAsLoadDefReg", ")", "continue", ";", "if", "(", "MO", ".", "getSubReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", ")", "return", "nullptr", ";", "SrcOperandIds", ".", "push_back", "(", "i", ")", ";", "}", "if", "(", "SrcOperandIds", ".", "empty", "(", ")", ")", "return", "nullptr", ";", "if", "(", "MachineInstr", "*", "FoldMI", "=", "foldMemoryOperand", "(", "MI", ",", "SrcOperandIds", ",", "*", "DefMI", ")", ")", "{", "FoldAsLoadDefReg", "=", "0", ";", "return", "FoldMI", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "optimizeLoadInstr", "-", "Try", "to", "remove", "the", "load", "by", "folding", "it", "to", "a", "register", "operand", "at", "the", "use", "." ]

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

[]

[ "<s>", "bool", "aarch64_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "GET_MODE_CLASS", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "aarch64_vector_mode_p", "(", "mode1", ")", "&&", "aarch64_vector_mode_p", "(", "mode2", ")", ")", "return", "true", ";", "if", "(", "aarch64_vector_mode_supported_p", "(", "mode1", ")", "||", "aarch64_vector_mode_supported_p", "(", "mode2", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "MODES_TIEABLE_P", ".", "In", "principle", "we", "should", "always", "return", "true", ".", "However", "due", "to", "issues", "with", "register", "allocation", "it", "is", "preferable", "to", "avoid", "tieing", "integer", "scalar", "and", "FP", "scalar", "modes", ".", "Executing", "integer", "operations", "in", "general", "registers", "is", "better", "than", "treating", "them", "as", "scalar", "vector", "operations", ".", "This", "reduces", "latency", "and", "avoids", "redundant", "int", "<", "-", ">", "FP", "moves", ".", "So", "tie", "modes", "if", "they", "are", "either", "the", "same", "class", ",", "or", "vector", "modes", "with", "other", "vector", "modes", ",", "vector", "structs", "or", "any", "scalar", "mode", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "MOSInsertCopies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "const", "TargetRegisterClass", "*", "WideRC", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "continue", ";", "case", "MOS", "::", "ASL", ":", "case", "MOS", "::", "LSR", ":", "case", "MOS", "::", "ROL", ":", "case", "MOS", "::", "ROR", ":", "WideRC", "=", "&", "MOS", "::", "AImag8RegClass", ";", "break", ";", "case", "MOS", "::", "IncMB", ":", "case", "MOS", "::", "DecMB", ":", "WideRC", "=", "&", "MOS", "::", "Anyi8RegClass", ";", "break", ";", "}", "for", "(", "unsigned", "Idx", "=", "0", ",", "EndIdx", "=", "I", "->", "getNumExplicitDefs", "(", ")", ";", "Idx", "!=", "EndIdx", ";", "++", "Idx", ")", "{", "MachineOperand", "&", "DstOp", "=", "I", "->", "getOperand", "(", "Idx", ")", ";", "if", "(", "!", "DstOp", ".", "isReg", "(", ")", "||", "!", "DstOp", ".", "isTied", "(", ")", "||", "!", "DstOp", ".", "getReg", "(", ")", ".", "isVirtual", "(", ")", ")", "continue", ";", "MachineOperand", "&", "SrcOp", "=", "I", "->", "getOperand", "(", "I", "->", "findTiedOperandIdx", "(", "Idx", ")", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcOp", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "DstOp", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "SrcRC", "->", "hasSuperClassEq", "(", "WideRC", ")", "||", "!", "DstRC", "->", "hasSuperClassEq", "(", "WideRC", ")", ")", "continue", ";", "if", "(", "SrcRC", "==", "&", "MOS", "::", "Imag8RegClass", "&&", "DstRC", "==", "&", "MOS", "::", "Imag8RegClass", ")", "continue", ";", "if", "(", "SrcRC", "!=", "WideRC", ")", "{", "Changed", "=", "true", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "I", ")", ";", "SrcOp", ".", "setReg", "(", "Builder", ".", "buildCopy", "(", "WideRC", ",", "SrcOp", ")", ".", "getReg", "(", "0", ")", ")", ";", "}", "if", "(", "DstRC", "!=", "WideRC", ")", "{", "Changed", "=", "true", ";", "Register", "NewDst", "=", "MRI", ".", "createVirtualRegister", "(", "WideRC", ")", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "Next", ")", ";", "Builder", ".", "buildCopy", "(", "DstOp", ",", "NewDst", ")", ";", "DstOp", ".", "setReg", "(", "NewDst", ")", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "MOS::ASL", "MOS::LSR", "MOS::ROL", "MOS::ROR", "MOS::AImag8RegClass", "MOS::IncMB", "MOS::DecMB", "MOS::Anyi8RegClass", "0", "MOS::Imag8RegClass", "MOS::Imag8RegClass", "0" ]

[]

[ "<s>", "const", "MipsFrameLowering", "*", "MipsFrameLowering", "::", "create", "(", "const", "MipsSubtarget", "&", "ST", ")", "{", "if", "(", "ST", ".", "inMips16Mode", "(", ")", ")", "return", "llvm", "::", "createMips16FrameLowering", "(", "ST", ")", ";", "return", "llvm", "::", "createMipsSEFrameLowering", "(", "ST", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "PPCTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "EnableQuadwordAtomics", "&&", "Subtarget", ".", "hasQuadwordAtomics", "(", ")", "&&", "Size", "==", "128", ")", "return", "AtomicExpansionKind", "::", "MaskedIntrinsic", ";", "return", "TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AI", ")", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

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

[]

[ "<s>", "void", "vms_c_register_includes", "(", "const", "char", "*", "sysroot", ",", "const", "char", "*", "iprefix", "ATTRIBUTE_UNUSED", ",", "int", "stdinc", ")", "{", "static", "const", "char", "dir_separator_str", "[", "]", "=", "{", "DIR_SEPARATOR", ",", "0", "}", ";", "struct", "cpp_dir", "*", "dir", ";", "if", "(", "!", "stdinc", ")", "return", ";", "for", "(", "dir", "=", "get_added_cpp_dirs", "(", "SYSTEM", ")", ";", "dir", "!=", "NULL", ";", "dir", "=", "dir", "->", "next", ")", "{", "const", "char", "*", "const", "*", "lib", ";", "for", "(", "lib", "=", "vms_std_modules", ";", "*", "lib", "!=", "NULL", ";", "lib", "++", ")", "{", "char", "*", "path", ";", "struct", "stat", "st", ";", "if", "(", "sysroot", "!=", "NULL", ")", "path", "=", "concat", "(", "sysroot", ",", "dir", "->", "name", ",", "dir_separator_str", ",", "*", "lib", ",", "NULL", ")", ";", "else", "path", "=", "concat", "(", "dir", "->", "name", ",", "dir_separator_str", ",", "*", "lib", ",", "NULL", ")", ";", "if", "(", "stat", "(", "path", ",", "&", "st", ")", "==", "0", "&&", "S_ISDIR", "(", "st", ".", "st_mode", ")", ")", "{", "cpp_dir", "*", "p", ";", "p", "=", "XNEW", "(", "cpp_dir", ")", ";", "p", "->", "next", "=", "NULL", ";", "p", "->", "name", "=", "path", ";", "p", "->", "sysp", "=", "1", ";", "p", "->", "construct", "=", "vms_construct_include_filename", ";", "p", "->", "user_supplied_p", "=", "0", ";", "add_cpp_dir_path", "(", "p", ",", "SYSTEM", ")", ";", "}", "else", "free", "(", "path", ")", ";", "}", "}", "}", "</s>" ]

[ "Find", "include", "modules", "in", "the", "include", "path", "." ]

[ "vms", "0", "0", "1", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_INIT_M0", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ".", "getIterator", "(", ")", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "AMDGPU", "::", "M0", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "case", "AMDGPU", "::", "GET_GROUPSTATICSIZE", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ";", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOVK_I32", ")", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "MFI", "->", "LDSSize", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "case", "AMDGPU", "::", "SI_INDIRECT_SRC_V1", ":", "case", "AMDGPU", "::", "SI_INDIRECT_SRC_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_SRC_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_SRC_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_SRC_V16", ":", "return", "emitIndirectSrc", "(", "MI", ",", "*", "BB", ",", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V1", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V16", ":", "return", "emitIndirectDst", "(", "MI", ",", "*", "BB", ",", "getSubtarget", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "case", "AMDGPU", "::", "SI_KILL", ":", "return", "splitKillBlock", "(", "MI", ",", "BB", ")", ";", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_INIT_M0", "SI", "AMDGPU::S_MOV_B32", "AMDGPU::M0", "0", "AMDGPU::GET_GROUPSTATICSIZE", "SI", "SI", "SI", "AMDGPU::S_MOVK_I32", "0", "AMDGPU::SI_INDIRECT_SRC_V1", "AMDGPU::SI_INDIRECT_SRC_V2", "AMDGPU::SI_INDIRECT_SRC_V4", "AMDGPU::SI_INDIRECT_SRC_V8", "AMDGPU::SI_INDIRECT_SRC_V16", "AMDGPU::SI_INDIRECT_DST_V1", "AMDGPU::SI_INDIRECT_DST_V2", "AMDGPU::SI_INDIRECT_DST_V4", "AMDGPU::SI_INDIRECT_DST_V8", "AMDGPU::SI_INDIRECT_DST_V16", "AMDGPU::SI_KILL", "AMDGPU" ]

[]

[ "<s>", "void", "sparc_flat_expand_prologue", "(", "void", ")", "{", "HOST_WIDE_INT", "size", ";", "rtx_insn", "*", "insn", ";", "sparc_leaf_function_p", "=", "optimize", ">", "0", "&&", "crtl", "->", "is_leaf", ";", "size", "=", "sparc_compute_frame_size", "(", "get_frame_size", "(", ")", ",", "sparc_leaf_function_p", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "||", "flag_stack_clash_protection", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "if", "(", "size", ">", "PROBE_INTERVAL", "&&", "size", ">", "get_stack_check_protect", "(", ")", ")", "sparc_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "size", "-", "get_stack_check_protect", "(", ")", ")", ";", "}", "else", "if", "(", "size", ">", "0", ")", "sparc_emit_probe_stack_range", "(", "get_stack_check_protect", "(", ")", ",", "size", ")", ";", "}", "if", "(", "sparc_save_local_in_regs_p", ")", "emit_save_or_restore_local_in_regs", "(", "stack_pointer_rtx", ",", "SPARC_STACK_BIAS", ",", "SORR_SAVE", ")", ";", "if", "(", "size", "==", "0", ")", ";", "else", "{", "rtx", "size_int_rtx", ",", "size_rtx", ";", "size_rtx", "=", "size_int_rtx", "=", "GEN_INT", "(", "-", "size", ")", ";", "if", "(", "size", "<=", "4096", ")", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "size_int_rtx", ")", ")", ";", "else", "if", "(", "size", "<=", "8192", "&&", "!", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "-", "4096", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "GEN_INT", "(", "4096", "-", "size", ")", ")", ")", ";", "}", "else", "{", "size_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "size_rtx", ",", "size_int_rtx", ")", ";", "insn", "=", "emit_insn", "(", "gen_stack_pointer_inc", "(", "size_rtx", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_stack_pointer_inc", "(", "size_int_rtx", ")", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "size_rtx", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "hard_frame_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "size", ")", ")", ")", ";", "}", "if", "(", "return_addr_reg_needed_p", "(", "sparc_leaf_function_p", ")", ")", "{", "rtx", "o7", "=", "gen_rtx_REG", "(", "Pmode", ",", "INCOMING_RETURN_ADDR_REGNUM", ")", ";", "rtx", "i7", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "insn", "=", "emit_move_insn", "(", "i7", ",", "o7", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "gen_rtx_SET", "(", "i7", ",", "o7", ")", ")", ";", "emit_use", "(", "i7", ")", ";", "}", "}", "if", "(", "frame_pointer_needed", ")", "{", "sparc_frame_base_reg", "=", "hard_frame_pointer_rtx", ";", "sparc_frame_base_offset", "=", "SPARC_STACK_BIAS", ";", "}", "else", "{", "sparc_frame_base_reg", "=", "stack_pointer_rtx", ";", "sparc_frame_base_offset", "=", "size", "+", "SPARC_STACK_BIAS", ";", "}", "if", "(", "sparc_n_global_fp_regs", ">", "0", ")", "emit_save_or_restore_global_fp_regs", "(", "sparc_frame_base_reg", ",", "sparc_frame_base_offset", "-", "sparc_apparent_frame_size", ",", "SORR_SAVE", ")", ";", "sparc_prologue_data_valid_p", "=", "true", ";", "}", "</s>" ]

[ "Expand", "the", "function", "prologue", ".", "The", "prologue", "is", "responsible", "for", "reserving", "storage", "for", "the", "frame", ",", "saving", "the", "call-saved", "registers", "and", "loading", "the", "GOT", "register", "if", "needed", "." ]

[ "sparc", "0", "0", "0", "4096", "8192", "4096", "1", "4096", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "rtx", "s390_function_arg", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "{", "if", "(", "cum", "->", "fprs", "+", "1", ">", "FP_ARG_NUM_REG", ")", "return", "0", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "fprs", "+", "16", ")", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "mode", ",", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "int", "n_gprs", "=", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "cum", "->", "gprs", "+", "n_gprs", ">", "GP_ARG_NUM_REG", ")", "return", "0", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "gprs", "+", "2", ")", ";", "}", "else", "if", "(", "type", "==", "void_type_node", ")", "return", "const0_rtx", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "On", "S/390", ",", "we", "use", "general", "purpose", "registers", "2", "through", "6", "to", "pass", "integer", ",", "pointer", ",", "and", "certain", "structure", "arguments", ",", "and", "floating", "point", "registers", "0", "and", "2", "(", "0", ",", "2", ",", "4", ",", "and", "6", "on", "64-bit", ")", "to", "pass", "floating", "point", "arguments", ".", "All", "remaining", "arguments", "are", "pushed", "to", "the", "stack", "." ]

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

[]

[ "<s>", "static", "void", "ix86_option_override", "(", "void", ")", "{", "opt_pass", "*", "pass_insert_vzeroupper", "=", "make_pass_insert_vzeroupper", "(", "g", ")", ";", "struct", "register_pass_info", "insert_vzeroupper_info", "=", "{", "pass_insert_vzeroupper", ",", "\"reload\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "ix86_option_override_internal", "(", "true", ",", "&", "global_options", ",", "&", "global_options_set", ")", ";", "register_pass", "(", "&", "insert_vzeroupper_info", ")", ";", "}", "</s>" ]

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

[ "i386", "\"reload\"", "1" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::SETB_C8r", "X86::SBB8rr", "X86::SETB_C16r", "X86::SBB16rr", "X86::SETB_C32r", "X86::SBB32rr", "X86::SETB_C64r", "X86::SBB64rr", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "WebAssemblyTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "const", "{", "for", "(", "BasicBlock", "*", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "Instruction", "&", "I", ":", "*", "BB", ")", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "30", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "UP", ".", "BEInsns", "=", "2", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "WebAssembly", "WebAssembly", "30", "0", "0", "2" ]

[]

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

[ "Return", "true", "if", "LSR", "major", "cost", "is", "number", "of", "registers", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "AArch64TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'x'", ":", "case", "'w'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", "||", "type", "->", "isVectorTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'z'", ":", "weight", "=", "CW_Constant", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "const", "char", "*", "XtensaTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "return", "\"unknown\"", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "\"unknown\"" ]

[]

[ "<s>", "static", "int", "sh_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "srcclass", ",", "reg_class_t", "dstclass", ")", "{", "if", "(", "dstclass", "==", "T_REGS", "||", "dstclass", "==", "PR_REGS", ")", "return", "10", ";", "if", "(", "dstclass", "==", "MAC_REGS", "&&", "srcclass", "==", "MAC_REGS", ")", "return", "4", ";", "if", "(", "mode", "==", "SImode", "&&", "TARGET_FMOVD", "&&", "REGCLASS_HAS_FP_REG", "(", "srcclass", ")", "&&", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", ")", "return", "4", ";", "if", "(", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", "&&", "srcclass", "==", "T_REGS", ")", "return", "(", "(", "TARGET_HARD_SH4", "&&", "!", "optimize_size", ")", "?", "10", ":", "7", ")", ";", "if", "(", "(", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", "&&", "srcclass", "==", "MAC_REGS", ")", "||", "(", "dstclass", "==", "MAC_REGS", "&&", "REGCLASS_HAS_FP_REG", "(", "srcclass", ")", ")", ")", "return", "9", ";", "if", "(", "(", "REGCLASS_HAS_FP_REG", "(", "dstclass", ")", "&&", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", ")", "||", "(", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", "&&", "REGCLASS_HAS_FP_REG", "(", "srcclass", ")", ")", ")", "{", "int", "addend", "=", "(", "mode", "==", "Pmode", ")", "?", "40", ":", "0", ";", "return", "(", "(", "TARGET_FMOVD", "?", "8", ":", "12", ")", "+", "addend", ")", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", "/", "8U", ")", ";", "}", "if", "(", "(", "dstclass", "==", "FPUL_REGS", "&&", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", ")", "||", "(", "srcclass", "==", "FPUL_REGS", "&&", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", ")", ")", "return", "5", ";", "if", "(", "(", "dstclass", "==", "FPUL_REGS", "&&", "(", "srcclass", "==", "PR_REGS", "||", "srcclass", "==", "MAC_REGS", "||", "srcclass", "==", "T_REGS", ")", ")", "||", "(", "srcclass", "==", "FPUL_REGS", "&&", "(", "dstclass", "==", "PR_REGS", "||", "dstclass", "==", "MAC_REGS", ")", ")", ")", "return", "7", ";", "if", "(", "(", "srcclass", "==", "FPSCR_REGS", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", ")", "||", "(", "dstclass", "==", "FPSCR_REGS", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", ")", ")", "return", "4", ";", "if", "(", "TARGET_FMOVD", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "srcclass", ")", "&&", "!", "REGCLASS_HAS_GENERAL_REG", "(", "dstclass", ")", ")", "return", "2", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "7", ")", "/", "8U", ")", ";", "if", "(", "(", "(", "dstclass", "==", "FP_REGS", "||", "dstclass", "==", "DF_REGS", ")", "&&", "(", "srcclass", "==", "PR_REGS", ")", ")", "||", "(", "(", "srcclass", "==", "FP_REGS", "||", "srcclass", "==", "DF_REGS", ")", "&&", "(", "dstclass", "==", "PR_REGS", ")", ")", ")", "return", "7", ";", "return", "2", "*", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "/", "4U", ")", ";", "}", "</s>" ]

[ "If", "SECONDARY", "*", "_RELOAD_CLASS", "says", "something", "about", "the", "src/dst", "pair", ",", "regclass", "uses", "this", "information", ".", "Hence", ",", "the", "general", "register", "<", "-", ">", "floating", "point", "register", "information", "here", "is", "not", "used", "for", "SFmode", "." ]

[ "sh", "10", "4", "4", "10", "7", "9", "40", "0", "8", "12", "7", "8U", "5", "7", "4", "2", "7", "8U", "7", "2", "3", "4U" ]

[]

[ "<s>", "bool", "AMDGPUAnnotateUniformValues", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "DA", "=", "&", "getAnalysis", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "MSSA", "=", "&", "getAnalysis", "<", "MemorySSAWrapperPass", ">", "(", ")", ".", "getMSSA", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "isEntryFunc", "=", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", ";", "visit", "(", "F", ")", ";", "noClobberClones", ".", "clear", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isEntryFunctionCC" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastMaterializeConstant", "(", "const", "Constant", "*", "C", ")", "{", "EVT", "CEVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "C", "->", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "!", "CEVT", ".", "isSimple", "(", ")", ")", "return", "0", ";", "MVT", "VT", "=", "CEVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "const", "ConstantFP", "*", "CFP", "=", "dyn_cast", "<", "ConstantFP", ">", "(", "C", ")", ")", "return", "PPCMaterializeFP", "(", "CFP", ",", "VT", ")", ";", "else", "if", "(", "const", "GlobalValue", "*", "GV", "=", "dyn_cast", "<", "GlobalValue", ">", "(", "C", ")", ")", "return", "PPCMaterializeGV", "(", "GV", ",", "VT", ")", ";", "else", "if", "(", "const", "ConstantInt", "*", "CI", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "C", ")", ")", "return", "PPCMaterializeInt", "(", "CI", ",", "VT", ",", "VT", "!=", "MVT", "::", "i1", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPC", "PPC", "PPC", "MVT::i1", "0" ]

[]

[ "<s>", "unsigned", "MBlazeInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "MBlaze", "::", "SWI", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "MBlaze", "MBlaze", "MBlaze::SWI", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "i386_pe_strip_name_encoding_full", "(", "const", "char", "*", "str", ")", "{", "const", "char", "*", "p", ";", "const", "char", "*", "name", "=", "default_strip_name_encoding", "(", "str", ")", ";", "if", "(", "*", "name", "==", "'@'", ")", "name", "++", ";", "p", "=", "strchr", "(", "name", ",", "'@'", ")", ";", "if", "(", "p", ")", "return", "ggc_alloc_string", "(", "name", ",", "p", "-", "name", ")", ";", "return", "name", ";", "}", "</s>" ]

[ "Also", "strip", "the", "fastcall", "prefix", "and", "stdcall", "suffix", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "MipsFrameLowering", "::", "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", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "isTargetMachO", "(", ")", "?", "\"e-m:o-i64:64-i128:128-n32:64-S128\"", ":", "(", "LittleEndian", "?", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", ":", "\"E-m:e-i64:64-i128:128-n32:64-S128\"", ")", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", "&", "DL", ")", ",", "TLInfo", "(", "TM", ")", "{", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"e-m:o-i64:64-i128:128-n32:64-S128\"", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", "\"E-m:e-i64:64-i128:128-n32:64-S128\"" ]

[]

[ "<s>", "bool", "SystemZPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZElimComparePass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createSystemZLongBranchPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMConstantPoolSymbol", "::", "hasSameValue", "(", "ARMConstantPoolValue", "*", "ACPV", ")", "{", "const", "ARMConstantPoolSymbol", "*", "ACPS", "=", "dyn_cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", ";", "return", "ACPS", "&&", "CPV_streq", "(", "ACPS", "->", "S", ",", "S", ")", "&&", "ARMConstantPoolValue", "::", "hasSameValue", "(", "ACPV", ")", ";", "}", "</s>" ]

[ "hasSameValue", "-", "Return", "true", "if", "this", "ARM", "constpool", "value", "can", "share", "the", "same", "constantpool", "entry", "as", "another", "ARM", "constpool", "value", "." ]

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

[]

[ "<s>", "MCFixupKindInfo", "const", "&", "MCS51AsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "MCS51", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_7_pcrel\"", ",", "3", ",", "7", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_13_pcrel\"", ",", "0", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_16_pm\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_call\"", ",", "0", ",", "22", ",", "0", "}", ",", "{", "\"fixup_6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_6_adiw\"", ",", "0", ",", "6", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_lo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hi8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hlo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_diff8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_diff16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_diff32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_lds_sts_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port5\"", ",", "3", ",", "5", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51::NumTargetFixupKinds", "\"fixup_32\"", "0", "32", "0", "\"fixup_7_pcrel\"", "3", "7", "\"fixup_13_pcrel\"", "0", "12", "\"fixup_16\"", "0", "16", "0", "\"fixup_16_pm\"", "0", "16", "0", "\"fixup_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi\"", "0", "8", "0", "\"fixup_hi8_ldi\"", "0", "8", "0", "\"fixup_hh8_ldi\"", "0", "8", "0", "\"fixup_ms8_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_neg\"", "0", "8", "0", "\"fixup_ms8_ldi_neg\"", "0", "8", "0", "\"fixup_lo8_ldi_pm\"", "0", "8", "0", "\"fixup_hi8_ldi_pm\"", "0", "8", "0", "\"fixup_hh8_ldi_pm\"", "0", "8", "0", "\"fixup_lo8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_call\"", "0", "22", "0", "\"fixup_6\"", "0", "16", "0", "\"fixup_6_adiw\"", "0", "6", "0", "\"fixup_lo8_ldi_gs\"", "0", "8", "0", "\"fixup_hi8_ldi_gs\"", "0", "8", "0", "\"fixup_8\"", "0", "8", "0", "\"fixup_8_lo8\"", "0", "8", "0", "\"fixup_8_hi8\"", "0", "8", "0", "\"fixup_8_hlo8\"", "0", "8", "0", "\"fixup_diff8\"", "0", "8", "0", "\"fixup_diff16\"", "0", "16", "0", "\"fixup_diff32\"", "0", "32", "0", "\"fixup_lds_sts_16\"", "0", "16", "0", "\"fixup_port6\"", "0", "16", "0", "\"fixup_port5\"", "3", "5", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "void", "sparc_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "tree", "type", "=", "arg", ".", "type", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "int", "regno", ",", "padding", ";", "function_arg_slotno", "(", "cum", ",", "mode", ",", "type", ",", "arg", ".", "named", ",", "false", ",", "&", "regno", ",", "&", "padding", ")", ";", "cum", "->", "words", "+=", "padding", ";", "if", "(", "TARGET_ARCH32", ")", "cum", "->", "words", "+=", "CEIL_NWORDS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "else", "{", "if", "(", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", ")", "{", "const", "int", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "<=", "0", ")", "cum", "->", "words", "++", ";", "else", "cum", "->", "words", "+=", "CEIL_NWORDS", "(", "size", ")", ";", "}", "else", "cum", "->", "words", "+=", "CEIL_NWORDS", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "}", "</s>" ]

[ "Handle", "the", "TARGET_FUNCTION_ARG_ADVANCE", "hook", ".", "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "static", "rtx", "tilepro_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", "&&", "symbolic_operand", "(", "x", ",", "Pmode", ")", "&&", "tilepro_tls_referenced_p", "(", "x", ")", ")", "{", "return", "tilepro_legitimize_tls_address", "(", "x", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "return", "tilepro_legitimize_pic_address", "(", "x", ",", "mode", ",", "0", ")", ";", "}", "else", "return", "x", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMIZE_ADDRESS", "." ]

[ "tilepro", "0" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "SystemZTTIImpl", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "BitSize", ">", "64", ")", "return", "TTI", "::", "TCC_Free", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isUInt", "<", "32", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "isUInt", "<", "32", ">", "(", "-", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "break", ";", "case", "Intrinsic", "::", "smul_with_overflow", ":", "case", "Intrinsic", "::", "umul_with_overflow", ":", "if", "(", "Idx", "==", "1", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "break", ";", "case", "Intrinsic", "::", "experimental_stackmap", ":", "if", "(", "(", "Idx", "<", "2", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "case", "Intrinsic", "::", "experimental_patchpoint_void", ":", "case", "Intrinsic", "::", "experimental_patchpoint_i64", ":", "if", "(", "(", "Idx", "<", "4", ")", "||", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "64", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "break", ";", "}", "return", "SystemZTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "SystemZ", "SystemZ", "Intrinsic::ID", "0", "64", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "1", "64", "32", "32", "Intrinsic::smul_with_overflow", "Intrinsic::umul_with_overflow", "1", "64", "32", "Intrinsic::experimental_stackmap", "2", "64", "64", "Intrinsic::experimental_patchpoint_void", "Intrinsic::experimental_patchpoint_i64", "4", "64", "64", "SystemZ" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "unsigned", "Size", "=", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "?", "4", ":", "8", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "Size", "-", "i", "-", "1", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "Idx", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "IsLittleEndian", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", "&", "0xFF", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", ">>", "8", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", ">>", "8", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", "&", "0xFF", ";", "}", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "4", "8", "0", "1", "8", "8", "8", "2", "0xFF", "3", "8", "2", "8", "3", "0xFF" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "int", "ix86_atom_sched_reorder", "(", "FILE", "*", "dump", ",", "int", "sched_verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "pn_ready", ",", "int", "clock_var", ")", "{", "int", "issue_rate", "=", "-", "1", ";", "int", "n_ready", "=", "*", "pn_ready", ";", "int", "i", ";", "rtx_insn", "*", "insn", ";", "int", "index", "=", "-", "1", ";", "issue_rate", "=", "ix86_issue_rate", "(", ")", ";", "if", "(", "!", "TARGET_CPU_P", "(", "BONNELL", ")", "&&", "!", "TARGET_CPU_P", "(", "SILVERMONT", ")", "&&", "!", "TARGET_CPU_P", "(", "INTEL", ")", ")", "return", "issue_rate", ";", "if", "(", "n_ready", "<=", "1", ")", "return", "issue_rate", ";", "if", "(", "!", "reload_completed", ")", "return", "issue_rate", ";", "if", "(", "(", "index", "=", "do_reorder_for_imul", "(", "ready", ",", "n_ready", ")", ")", ">=", "0", ")", "{", "if", "(", "sched_verbose", ">", "1", ")", "fprintf", "(", "dump", ",", "\";;\\tatom sched_reorder: put %d insn on top\\n\"", ",", "INSN_UID", "(", "ready", "[", "index", "]", ")", ")", ";", "insn", "=", "ready", "[", "index", "]", ";", "for", "(", "i", "=", "index", ";", "i", "<", "n_ready", "-", "1", ";", "i", "++", ")", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "1", "]", ";", "ready", "[", "n_ready", "-", "1", "]", "=", "insn", ";", "return", "issue_rate", ";", "}", "if", "(", "clock_var", "!=", "0", "&&", "!", "sel_sched_p", "(", ")", "&&", "swap_top_of_ready_list", "(", "ready", ",", "n_ready", ")", ")", "{", "if", "(", "sched_verbose", ">", "1", ")", "fprintf", "(", "dump", ",", "\";;\\tslm sched_reorder: swap %d and %d insns\\n\"", ",", "INSN_UID", "(", "ready", "[", "n_ready", "-", "1", "]", ")", ",", "INSN_UID", "(", "ready", "[", "n_ready", "-", "2", "]", ")", ")", ";", "insn", "=", "ready", "[", "n_ready", "-", "1", "]", ";", "ready", "[", "n_ready", "-", "1", "]", "=", "ready", "[", "n_ready", "-", "2", "]", ";", "ready", "[", "n_ready", "-", "2", "]", "=", "insn", ";", "}", "return", "issue_rate", ";", "}", "</s>" ]

[ "Perform", "possible", "reodering", "of", "ready", "list", "for", "Atom/Silvermont", "only", ".", "Return", "issue", "rate", "." ]

[ "i386", "1", "1", "1", "0", "1", "\";;\\tatom sched_reorder: put %d insn on top\\n\"", "1", "1", "1", "0", "1", "\";;\\tslm sched_reorder: swap %d and %d insns\\n\"", "1", "2", "1", "1", "2", "2" ]

[]

[ "<s>", "static", "bool", "unspec_caller_rtx_p", "(", "rtx", "pat", ")", "{", "rtx", "base", ",", "offset", ";", "int", "i", ";", "split_const", "(", "pat", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "base", ",", "1", ")", "==", "UNSPEC_CALLER", ")", "return", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "base", ",", "0", ")", ";", "i", "++", ")", "if", "(", "unspec_caller_rtx_p", "(", "XVECEXP", "(", "base", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "PAT", "includes", "UNSPEC_CALLER", "unspec", "pattern", "." ]

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

[]

[ "<s>", "Register", "(", ")", "{", "ARMTargetMachine", "::", "registerAsmPrinter", "(", "createARMCodePrinterPass", ")", ";", "}", "</s>" ]

[ "Base", "register", "." ]

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

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "getZero", "(", "const", "SDLoc", "&", "dl", ",", "MVT", "Ty", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Ty", ".", "isVector", "(", ")", ")", "{", "assert", "(", "Ty", ".", "isInteger", "(", ")", "&&", "\"Only integer vectors are supported here\"", ")", ";", "unsigned", "W", "=", "Ty", ".", "getSizeInBits", "(", ")", ";", "if", "(", "W", "<=", "64", ")", "return", "DAG", ".", "getBitcast", "(", "Ty", ",", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "MVT", "::", "getIntegerVT", "(", "W", ")", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "SPLAT_VECTOR", ",", "dl", ",", "Ty", ",", "getZero", "(", "dl", ",", "MVT", "::", "i32", ",", "DAG", ")", ")", ";", "}", "if", "(", "Ty", ".", "isInteger", "(", ")", ")", "return", "DAG", ".", "getConstant", "(", "0", ",", "dl", ",", "Ty", ")", ";", "if", "(", "Ty", ".", "isFloatingPoint", "(", ")", ")", "return", "DAG", ".", "getConstantFP", "(", "0.0", ",", "dl", ",", "Ty", ")", ";", "llvm_unreachable", "(", "\"Invalid type for zero\"", ")", ";", "}", "</s>" ]

[ "Return", "a", "SCEV", "for", "the", "constant", "0", "of", "a", "specific", "type", "." ]

[ "Hexagon", "Hexagon", "\"Only integer vectors are supported here\"", "64", "0", "MVT::getIntegerVT", "ISD::SPLAT_VECTOR", "MVT::i32", "0", "0.0", "\"Invalid type for zero\"" ]

[]

[ "<s>", "bool", "microblaze_expand_block_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "length", ",", "rtx", "align_rtx", ")", "{", "if", "(", "GET_CODE", "(", "length", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "bytes", "=", "INTVAL", "(", "length", ")", ";", "int", "align", "=", "INTVAL", "(", "align_rtx", ")", ";", "if", "(", "align", ">", "UNITS_PER_WORD", ")", "{", "align", "=", "UNITS_PER_WORD", ";", "}", "else", "if", "(", "align", "<", "UNITS_PER_WORD", ")", "{", "if", "(", "INTVAL", "(", "length", ")", "<=", "MAX_MOVE_BYTES", ")", "{", "move_by_pieces", "(", "dest", ",", "src", ",", "bytes", ",", "align", ",", "0", ")", ";", "return", "true", ";", "}", "else", "return", "false", ";", "}", "if", "(", "INTVAL", "(", "length", ")", "<=", "2", "*", "MAX_MOVE_BYTES", ")", "{", "microblaze_block_move_straight", "(", "dest", ",", "src", ",", "INTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "optimize", ")", "{", "microblaze_block_move_loop", "(", "dest", ",", "src", ",", "INTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "movmemsi", "instruction", "." ]

[ "microblaze", "0", "2" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "tree", "ix86_handle_shared_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "VAR_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to variables\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

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

[ "i386", "\"%qE attribute only applies to variables\"" ]

[]

[ "<s>", "static", "void", "sparc_add_gc_roots", "(", ")", "{", "ggc_add_rtx_root", "(", "&", "sparc_compare_op0", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "sparc_compare_op1", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "global_offset_table", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "get_pc_symbol", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "sparc_addr_diff_list", ",", "1", ")", ";", "ggc_add_rtx_root", "(", "&", "sparc_addr_list", ",", "1", ")", ";", "ggc_add_root", "(", "ultra_pipe_hist", ",", "ARRAY_SIZE", "(", "ultra_pipe_hist", ")", ",", "sizeof", "(", "ultra_pipe_hist", "[", "0", "]", ")", ",", "&", "mark_ultrasparc_pipeline_state", ")", ";", "}", "</s>" ]

[ "Called", "to", "register", "all", "of", "our", "global", "variables", "with", "the", "garbage", "collector", "." ]

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

[]

[ "<s>", "const", "unsigned", "*", "PPCRegisterInfo", "::", "getCallPreservedMask", "(", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "CSR_Darwin64_RegMask", ":", "CSR_Darwin32_RegMask", ";", "return", "Subtarget", ".", "isPPC64", "(", ")", "?", "CSR_SVR464_RegMask", ":", "CSR_SVR432_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HexagonHazardRecognizer", "::", "ShouldPreferAnother", "(", "SUnit", "*", "SU", ")", "{", "if", "(", "PrefVectorStoreNew", "!=", "nullptr", "&&", "PrefVectorStoreNew", "!=", "SU", ")", "return", "true", ";", "if", "(", "UsesLoad", "&&", "SU", "->", "isInstr", "(", ")", "&&", "SU", "->", "getInstr", "(", ")", "->", "mayLoad", "(", ")", ")", "return", "true", ";", "return", "UsesDotCur", "&&", "(", "(", "SU", "==", "UsesDotCur", ")", "^", "(", "DotCurPNum", "==", "(", "int", ")", "PacketNum", ")", ")", ";", "}", "</s>" ]

[ "ShouldPreferAnother", "-", "This", "callback", "may", "be", "invoked", "if", "getHazardType", "returns", "NoHazard", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "HexagonTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "HexagonISD", "::", "CONST32", ":", "return", "\"HexagonISD::CONST32\"", ";", "case", "HexagonISD", "::", "CONST32_GP", ":", "return", "\"HexagonISD::CONST32_GP\"", ";", "case", "HexagonISD", "::", "CONST32_Int_Real", ":", "return", "\"HexagonISD::CONST32_Int_Real\"", ";", "case", "HexagonISD", "::", "ADJDYNALLOC", ":", "return", "\"HexagonISD::ADJDYNALLOC\"", ";", "case", "HexagonISD", "::", "CMPICC", ":", "return", "\"HexagonISD::CMPICC\"", ";", "case", "HexagonISD", "::", "CMPFCC", ":", "return", "\"HexagonISD::CMPFCC\"", ";", "case", "HexagonISD", "::", "BRICC", ":", "return", "\"HexagonISD::BRICC\"", ";", "case", "HexagonISD", "::", "BRFCC", ":", "return", "\"HexagonISD::BRFCC\"", ";", "case", "HexagonISD", "::", "SELECT_ICC", ":", "return", "\"HexagonISD::SELECT_ICC\"", ";", "case", "HexagonISD", "::", "SELECT_FCC", ":", "return", "\"HexagonISD::SELECT_FCC\"", ";", "case", "HexagonISD", "::", "Hi", ":", "return", "\"HexagonISD::Hi\"", ";", "case", "HexagonISD", "::", "Lo", ":", "return", "\"HexagonISD::Lo\"", ";", "case", "HexagonISD", "::", "FTOI", ":", "return", "\"HexagonISD::FTOI\"", ";", "case", "HexagonISD", "::", "ITOF", ":", "return", "\"HexagonISD::ITOF\"", ";", "case", "HexagonISD", "::", "CALL", ":", "return", "\"HexagonISD::CALL\"", ";", "case", "HexagonISD", "::", "RET_FLAG", ":", "return", "\"HexagonISD::RET_FLAG\"", ";", "case", "HexagonISD", "::", "BR_JT", ":", "return", "\"HexagonISD::BR_JT\"", ";", "case", "HexagonISD", "::", "TC_RETURN", ":", "return", "\"HexagonISD::TC_RETURN\"", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "HexagonISD::CONST32", "\"HexagonISD::CONST32\"", "HexagonISD::CONST32_GP", "\"HexagonISD::CONST32_GP\"", "HexagonISD::CONST32_Int_Real", "\"HexagonISD::CONST32_Int_Real\"", "HexagonISD::ADJDYNALLOC", "\"HexagonISD::ADJDYNALLOC\"", "HexagonISD::CMPICC", "\"HexagonISD::CMPICC\"", "HexagonISD::CMPFCC", "\"HexagonISD::CMPFCC\"", "HexagonISD::BRICC", "\"HexagonISD::BRICC\"", "HexagonISD::BRFCC", "\"HexagonISD::BRFCC\"", "HexagonISD::SELECT_ICC", "\"HexagonISD::SELECT_ICC\"", "HexagonISD::SELECT_FCC", "\"HexagonISD::SELECT_FCC\"", "HexagonISD::Hi", "\"HexagonISD::Hi\"", "HexagonISD::Lo", "\"HexagonISD::Lo\"", "HexagonISD::FTOI", "\"HexagonISD::FTOI\"", "HexagonISD::ITOF", "\"HexagonISD::ITOF\"", "HexagonISD::CALL", "\"HexagonISD::CALL\"", "HexagonISD::RET_FLAG", "\"HexagonISD::RET_FLAG\"", "HexagonISD::BR_JT", "\"HexagonISD::BR_JT\"", "HexagonISD::TC_RETURN", "\"HexagonISD::TC_RETURN\"" ]

[]

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

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

[ "AVR" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getPPCSubtarget", "(", ")", ".", "hasVSX", "(", ")", ")", "addPass", "(", "createPPCVSXCopyCleanupPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

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

[]

[ "<s>", "bool", "SIPeepholeSDWA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasSDWA", "(", ")", "||", "!", "AMDGPU", "::", "isVI", "(", "ST", ")", ")", "{", "return", "false", ";", "}", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "matchSDWAOperands", "(", "MF", ")", ";", "for", "(", "const", "auto", "&", "OperandPair", ":", "SDWAOperands", ")", "{", "const", "auto", "&", "Operand", "=", "OperandPair", ".", "second", ";", "MachineInstr", "*", "PotentialMI", "=", "Operand", "->", "potentialToConvert", "(", "TII", ")", ";", "if", "(", "PotentialMI", "&&", "isConvertibleToSDWA", "(", "*", "PotentialMI", ")", ")", "{", "PotentialMatches", "[", "PotentialMI", "]", ".", "push_back", "(", "Operand", ".", "get", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "PotentialPair", ":", "PotentialMatches", ")", "{", "MachineInstr", "&", "PotentialMI", "=", "*", "PotentialPair", ".", "first", ";", "convertToSDWA", "(", "PotentialMI", ",", "PotentialPair", ".", "second", ")", ";", "}", "PotentialMatches", ".", "clear", "(", ")", ";", "SDWAOperands", ".", "clear", "(", ")", ";", "bool", "Ret", "=", "!", "ConvertedInstructions", ".", "empty", "(", ")", ";", "while", "(", "!", "ConvertedInstructions", ".", "empty", "(", ")", ")", "legalizeScalarOperands", "(", "*", "ConvertedInstructions", ".", "pop_back_val", "(", ")", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::isVI" ]

[]

[ "<s>", "void", "SPURegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "int", "LinkSlotOffset", "=", "SPUFrameInfo", "::", "stackSlotSize", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "SPU", "::", "RET", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "assert", "(", "(", "FrameSize", "&", "0xf", ")", "==", "0", "&&", "\"SPURegisterInfo::emitEpilogue: FrameSize not aligned\"", ")", ";", "if", "(", "FrameSize", ">", "16", "||", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "FrameSize", "=", "FrameSize", "+", "SPUFrameInfo", "::", "minStackSize", "(", ")", ";", "if", "(", "isInt", "<", "10", ">", "(", "FrameSize", "+", "LinkSlotOffset", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQDr128", ")", ",", "SPU", "::", "R0", ")", ".", "addImm", "(", "FrameSize", "+", "LinkSlotOffset", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "AIr32", ")", ",", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "else", "if", "(", "FrameSize", "<=", "(", "1", "<<", "16", ")", "-", "1", "&&", "FrameSize", ">=", "-", "(", "1", "<<", "16", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "STQDr128", ")", ",", "SPU", "::", "R2", ")", ".", "addImm", "(", "16", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "ILr32", ")", ",", "SPU", "::", "R2", ")", ".", "addImm", "(", "FrameSize", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "Ar32", ")", ",", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQDr128", ")", ",", "SPU", "::", "R0", ")", ".", "addImm", "(", "16", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "SFIr32", ")", ",", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ".", "addImm", "(", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "SPU", "::", "LQXr128", ")", ",", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R2", ")", ".", "addReg", "(", "SPU", "::", "R1", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Unhandled frame size: \"", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::RET", "\"Can only insert epilog into returning blocks\"", "0xf", "0", "\"SPURegisterInfo::emitEpilogue: FrameSize not aligned\"", "16", "SPU", "10", "SPU::LQDr128", "SPU::R0", "SPU::R1", "SPU::AIr32", "SPU::R1", "SPU::R1", "1", "16", "1", "1", "16", "SPU::STQDr128", "SPU::R2", "16", "SPU::R1", "SPU::ILr32", "SPU::R2", "SPU::Ar32", "SPU::R1", "SPU::R1", "SPU::R2", "SPU::LQDr128", "SPU::R0", "16", "SPU::R1", "SPU::SFIr32", "SPU::R2", "SPU::R2", "16", "SPU::LQXr128", "SPU::R2", "SPU::R2", "SPU::R1", "\"Unhandled frame size: \"" ]

[]