Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "riscv_expand_op", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "if", "(", "can_create_pseudo_p", "(", ")", ")", "{", "rtx", "result", ";", "if", "(", "GET_RTX_CLASS", "(", "code", ")", "==", "RTX_UNARY", ")", "result", "=", "expand_simple_unop", "(", "mode", ",", "code", ",", "op1", ",", "NULL_RTX", ",", "false", ")", ";", "else", "result", "=", "expand_simple_binop", "(", "mode", ",", "code", ",", "op1", ",", "op2", ",", "NULL_RTX", ",", "false", ",", "OPTAB_DIRECT", ")", ";", "riscv_emit_move", "(", "op0", ",", "result", ")", ";", "}", "else", "{", "rtx", "pat", ";", "if", "(", "GET_RTX_CLASS", "(", "code", ")", "==", "RTX_UNARY", ")", "pat", "=", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "op1", ")", ";", "else", "pat", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op1", ",", "op2", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "pat", ")", ")", ";", "}", "}", "</s>" ]

[ "Helper", "function", "to", "operation", "for", "rtx_code", "CODE", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "rtx", "aarch64_simd_make_constant", "(", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vals", ")", ";", "rtx", "const_dup", ";", "rtx", "const_vec", "=", "NULL_RTX", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_const", "=", "0", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "vals", ")", "==", "CONST_VECTOR", ")", "const_vec", "=", "vals", ";", "else", "if", "(", "GET_CODE", "(", "vals", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "rtx", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "CONST_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", ")", "n_const", "++", ";", "}", "if", "(", "n_const", "==", "n_elts", ")", "const_vec", "=", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "const_vec", "!=", "NULL_RTX", "&&", "aarch64_simd_valid_immediate", "(", "const_vec", ",", "mode", ",", "false", ",", "NULL", ")", ")", "return", "const_vec", ";", "else", "if", "(", "(", "const_dup", "=", "aarch64_simd_dup_constant", "(", "vals", ")", ")", "!=", "NULL_RTX", ")", "return", "const_dup", ";", "else", "if", "(", "const_vec", "!=", "NULL_RTX", ")", "return", "const_vec", ";", "else", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "VALS", ",", "which", "is", "a", "PARALLEL", "containing", "only", "constants", "(", "for", "vec_init", ")", "or", "CONST_VECTOR", ",", "efficiently", "into", "a", "register", ".", "Returns", "an", "RTX", "to", "copy", "into", "the", "register", ",", "or", "NULL_RTX", "for", "a", "PARALLEL", "that", "can", "not", "be", "converted", "into", "a", "CONST_VECTOR", "." ]

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

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "==", "AMDGPU", "::", "NoRegister", ")", "return", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "NumBytes", "!=", "0", "&&", "hasSP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "NumBytes", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::NoRegister", "SI", "SI", "SI", "0", "AMDGPU::S_SUB_U32" ]

[]

[ "<s>", "SDValue", "LanaiSelectionDAGInfo", "::", "EmitTargetCodeForMemcpy", "(", "SelectionDAG", "&", ",", "const", "SDLoc", "&", ",", "SDValue", ",", "SDValue", ",", "SDValue", ",", "SDValue", "Size", ",", "Align", ",", "bool", ",", "bool", ",", "MachinePointerInfo", ",", "MachinePointerInfo", ")", "const", "{", "ConstantSDNode", "*", "ConstantSize", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "if", "(", "!", "ConstantSize", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memcpy", "." ]

[ "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "M680x0InstrInfo", "::", "getStackSlotRange", "(", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "SubIdx", ",", "unsigned", "&", "Size", ",", "unsigned", "&", "Offset", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Size", "=", "4", ";", "Offset", "=", "0", ";", "return", "true", ";", "}", "</s>" ]

[ "Compute", "the", "size", "in", "bytes", "and", "offset", "within", "a", "stack", "slot", "of", "a", "spilled", "register", "or", "subregister", "." ]

[ "M680x0", "M680x0", "4", "0" ]

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "TM", ".", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "TVM" ]

[]

[ "<s>", "EVT", "ARM64TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "Fast", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "!", "IsMemset", "&&", "Size", ">=", "16", "&&", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoImplicitFloat", ")", "&&", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "||", "(", "allowsUnalignedMemoryAccesses", "(", "MVT", "::", "f128", ",", "0", ",", "&", "Fast", ")", "&&", "Fast", ")", ")", ")", "return", "MVT", "::", "f128", ";", "return", "Size", ">=", "8", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "16", "16", "MVT::f128", "0", "MVT::f128", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printSymbol", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ",", "bool", "hi", ")", "const", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", "&&", "\"Unknown symbol operand\"", ")", ";", "O", "<<", "'#'", "<<", "(", "hi", "?", "\"HI\"", ":", "\"LO\"", ")", "<<", "\"(#\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "')'", ";", "}", "</s>" ]

[ "Print", "a", "MCSymbol", "as", "an", "operand", "." ]

[ "Hexagon", "Hexagon", "\"Unknown symbol operand\"", "\"HI\"", "\"LO\"", "\"(#\"" ]

[]

[ "<s>", "bool", "isLegalMaskedScatter", "(", "Type", "*", "DataType", ")", "{", "return", "ST", "->", "hasSVE", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "scatter", "." ]

[ "AArch64" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isShuffleMaskLegal", "(", "ArrayRef", "<", "int", ">", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "4", "&&", "(", "VT", ".", "is128BitVector", "(", ")", "||", "VT", ".", "is64BitVector", "(", ")", ")", ")", "{", "unsigned", "PFIndexes", "[", "4", "]", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "if", "(", "M", "[", "i", "]", "<", "0", ")", "PFIndexes", "[", "i", "]", "=", "8", ";", "else", "PFIndexes", "[", "i", "]", "=", "M", "[", "i", "]", ";", "}", "unsigned", "PFTableIndex", "=", "PFIndexes", "[", "0", "]", "*", "9", "*", "9", "*", "9", "+", "PFIndexes", "[", "1", "]", "*", "9", "*", "9", "+", "PFIndexes", "[", "2", "]", "*", "9", "+", "PFIndexes", "[", "3", "]", ";", "unsigned", "PFEntry", "=", "PerfectShuffleTable", "[", "PFTableIndex", "]", ";", "unsigned", "Cost", "=", "(", "PFEntry", ">>", "30", ")", ";", "if", "(", "Cost", "<=", "4", ")", "return", "true", ";", "}", "bool", "DummyBool", ";", "int", "DummyInt", ";", "unsigned", "DummyUnsigned", ";", "return", "(", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "64", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "32", ")", "||", "isREVMask", "(", "M", ",", "VT", ",", "16", ")", "||", "isEXTMask", "(", "M", ",", "VT", ",", "DummyBool", ",", "DummyUnsigned", ")", "||", "isTRNMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIPMask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isTRN_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isUZP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isZIP_v_undef_Mask", "(", "M", ",", "VT", ",", "DummyUnsigned", ")", "||", "isINSMask", "(", "M", ",", "VT", ".", "getVectorNumElements", "(", ")", ",", "DummyBool", ",", "DummyInt", ")", "||", "isConcatMask", "(", "M", ",", "VT", ",", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "4", "4", "0", "4", "0", "8", "0", "9", "9", "9", "1", "9", "9", "2", "9", "3", "30", "4", "0", "64", "32", "16", "128" ]

[]

[ "<s>", "virtual", "const", "Tile64InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

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

[ "Tile64" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printInst", "(", "const", "HexagonMCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "const", "char", "startPacket", "=", "'{'", ",", "endPacket", "=", "'}'", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "assert", "(", "MI", "->", "isPacketEnd", "(", ")", "&&", "\"Loop-end must also end the packet\"", ")", ";", "if", "(", "MI", "->", "isPacketBegin", "(", ")", ")", "{", "HexagonMCInst", "Nop", ";", "StringRef", "NoAnnot", ";", "Nop", ".", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Nop", ".", "setPacketBegin", "(", "MI", "->", "isPacketBegin", "(", ")", ")", ";", "printInst", "(", "&", "Nop", ",", "O", ",", "NoAnnot", ")", ";", "}", "if", "(", "MI", "->", "isPacketEnd", "(", ")", ")", "O", "<<", "PacketPadding", "<<", "endPacket", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "}", "else", "{", "if", "(", "MI", "->", "isPacketBegin", "(", ")", ")", "O", "<<", "PacketPadding", "<<", "startPacket", "<<", "'\\n'", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "if", "(", "MI", "->", "isPacketEnd", "(", ")", ")", "O", "<<", "'\\n'", "<<", "PacketPadding", "<<", "endPacket", ";", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon::ENDLOOP0", "\"Loop-end must also end the packet\"", "Hexagon", "Hexagon::A2_nop" ]

[]

[ "<s>", "static", "void", "output_asm_btfext_core_reloc", "(", "bpf_core_reloc_ref", "bpfcr", ")", "{", "bpfcr", "->", "bpfcr_astr_off", "+=", "ctfc_get_strtab_len", "(", "ctf_get_tu_ctfc", "(", ")", ",", "CTF_STRTAB", ")", ";", "dw2_assemble_integer", "(", "4", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "bpfcr", "->", "bpfcr_insn_label", ")", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t%s bpfcr_insn\\n\"", ",", "ASM_COMMENT_START", ")", ";", "dw2_asm_output_data", "(", "4", ",", "bpfcr", "->", "bpfcr_type", ",", "\"bpfcr_type\"", ")", ";", "dw2_asm_output_data", "(", "4", ",", "bpfcr", "->", "bpfcr_astr_off", ",", "\"bpfcr_astr_off\"", ")", ";", "dw2_asm_output_data", "(", "4", ",", "bpfcr", "->", "bpfcr_kind", ",", "\"bpfcr_kind\"", ")", ";", "}", "</s>" ]

[ "Output", "a", "single", "CO-RE", "relocation", "record", "." ]

[ "bpf", "4", "\"\\t%s bpfcr_insn\\n\"", "4", "\"bpfcr_type\"", "4", "\"bpfcr_astr_off\"", "4", "\"bpfcr_kind\"" ]

[]

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

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

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

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_ctr", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxQRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrq_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxVRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrv_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "HvxWRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "PS_vloadrw_ai", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::L2_loadri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::L2_loadrd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::LDriw_pred", "0", "Hexagon::ModRegsRegClass", "Hexagon::LDriw_ctr", "0", "Hexagon::HvxQRRegClass", "Hexagon::PS_vloadrq_ai", "0", "Hexagon::HvxVRRegClass", "Hexagon::PS_vloadrv_ai", "0", "Hexagon::HvxWRRegClass", "Hexagon::PS_vloadrw_ai", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "pa_output_function_prologue", "(", "FILE", "*", "file", ")", "{", "ASM_OUTPUT_LABEL", "(", "file", ",", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ")", ";", "fputs", "(", "\"\\t.PROC\\n\"", ",", "file", ")", ";", "fprintf", "(", "file", ",", "\"\\t.CALLINFO FRAME=\"", "HOST_WIDE_INT_PRINT_DEC", ",", "actual_fsize", ")", ";", "if", "(", "crtl", "->", "is_leaf", ")", "fputs", "(", "\",NO_CALLS\"", ",", "file", ")", ";", "else", "fputs", "(", "\",CALLS\"", ",", "file", ")", ";", "if", "(", "rp_saved", ")", "fputs", "(", "\",SAVE_RP\"", ",", "file", ")", ";", "if", "(", "frame_pointer_needed", ")", "fputs", "(", "\",SAVE_SP\"", ",", "file", ")", ";", "if", "(", "gr_saved", ")", "fprintf", "(", "file", ",", "\",ENTRY_GR=%d\"", ",", "gr_saved", "+", "2", ")", ";", "if", "(", "fr_saved", ")", "fprintf", "(", "file", ",", "\",ENTRY_FR=%d\"", ",", "fr_saved", "+", "11", ")", ";", "fputs", "(", "\"\\n\\t.ENTRY\\n\"", ",", "file", ")", ";", "remove_useless_addtr_insns", "(", "0", ")", ";", "}", "</s>" ]

[ "On", "HP-PA", ",", "move-double", "insns", "between", "fpu", "and", "cpu", "need", "an", "8-byte", "block", "of", "memory", ".", "If", "any", "fpu", "reg", "is", "used", "in", "the", "function", ",", "we", "allocate", "such", "a", "block", "here", ",", "at", "the", "bottom", "of", "the", "frame", ",", "just", "in", "case", "it", "'s", "needed", ".", "If", "this", "function", "is", "a", "leaf", "procedure", ",", "then", "we", "may", "choose", "not", "to", "do", "a", "``", "save", "''", "insn", ".", "The", "decision", "about", "whether", "or", "not", "to", "do", "this", "is", "made", "in", "regclass.c", "." ]

[ "pa", "0", "0", "\"\\t.PROC\\n\"", "\"\\t.CALLINFO FRAME=\"", "\",NO_CALLS\"", "\",CALLS\"", "\",SAVE_RP\"", "\",SAVE_SP\"", "\",ENTRY_GR=%d\"", "2", "\",ENTRY_FR=%d\"", "11", "\"\\n\\t.ENTRY\\n\"", "0" ]

[]

[ "<s>", "static", "bool", "rx_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "PRE_DEC", ":", "case", "POST_INC", ":", "return", "true", ";", "case", "MINUS", ":", "case", "PLUS", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "return", "true", ";", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "return", "true", ";", "case", "CONST_INT", ":", "if", "(", "(", "(", "INTVAL", "(", "addr", ")", "&", "3", ")", "==", "0", ")", "&&", "IN_RANGE", "(", "INTVAL", "(", "addr", ")", ",", "4", ",", "0xfffc", ")", ")", "return", "false", ";", "return", "true", ";", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "true", ";", "case", "MULT", ":", "return", "true", ";", "default", ":", "return", "true", ";", "}", "case", "CONST_INT", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "REG", ":", "return", "false", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "rx", "0", "0", "1", "3", "0", "4", "0xfffc" ]

[]

[ "<s>", "static", "int", "microblaze_version_to_int", "(", "const", "char", "*", "version", ")", "{", "const", "char", "*", "p", ",", "*", "v", ";", "const", "char", "*", "tmpl", "=", "\"vXX.YY.Z\"", ";", "int", "iver", "=", "0", ";", "p", "=", "version", ";", "v", "=", "tmpl", ";", "while", "(", "*", "p", ")", "{", "if", "(", "*", "v", "==", "'X'", ")", "{", "if", "(", "*", "p", "==", "'.'", ")", "{", "*", "v", "++", ";", "}", "else", "{", "if", "(", "!", "(", "*", "p", ">=", "'0'", "&&", "*", "p", "<=", "'9'", ")", ")", "return", "-", "1", ";", "iver", "+=", "(", "int", ")", "(", "*", "p", "-", "'0'", ")", ";", "iver", "*=", "10", ";", "}", "}", "else", "if", "(", "*", "v", "==", "'Y'", ")", "{", "if", "(", "!", "(", "*", "p", ">=", "'0'", "&&", "*", "p", "<=", "'9'", ")", ")", "return", "-", "1", ";", "iver", "+=", "(", "int", ")", "(", "*", "p", "-", "'0'", ")", ";", "iver", "*=", "10", ";", "}", "else", "if", "(", "*", "v", "==", "'Z'", ")", "{", "if", "(", "!", "(", "*", "p", ">=", "'a'", "&&", "*", "p", "<=", "'z'", ")", ")", "return", "-", "1", ";", "iver", "*=", "10", ";", "iver", "+=", "(", "int", ")", "(", "*", "p", "-", "'a'", ")", ";", "}", "else", "{", "if", "(", "*", "p", "!=", "*", "v", ")", "return", "-", "1", ";", "}", "v", "++", ";", "p", "++", ";", "}", "if", "(", "*", "p", ")", "return", "-", "1", ";", "return", "iver", ";", "}", "</s>" ]

[ "Convert", "a", "version", "number", "of", "the", "form", "``", "vX.YY.Z", "''", "to", "an", "integer", "encoding", "for", "easier", "range", "comparison", "." ]

[ "microblaze", "\"vXX.YY.Z\"", "0", "1", "10", "1", "10", "1", "10", "1", "1" ]

[]

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

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

[ "MMIX", "MMIX", "MMIXOperand::createToken", "\"unexpected token\"" ]

[]

[ "<s>", "void", "BPFInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "BPF", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BPF", "::", "MOV_rr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::GPRRegClass", "BPF::MOV_rr", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "void", "ARMBankConflictHazardRecognizer", "::", "Reset", "(", ")", "{", "Accesses", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "mips_can_use_return_insn", "(", ")", "{", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "if", "(", "regs_ever_live", "[", "31", "]", "||", "current_function_profile", ")", "return", "0", ";", "if", "(", "TARGET_MIPS16", "&&", "mips16_hard_float", "&&", "!", "aggregate_value_p", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", "&&", "(", "GET_MODE_CLASS", "(", "DECL_MODE", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ")", "==", "MODE_FLOAT", ")", "&&", "(", "!", "TARGET_SINGLE_FLOAT", "||", "(", "GET_MODE_SIZE", "(", "DECL_MODE", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ")", "<=", "4", ")", ")", ")", "return", "0", ";", "if", "(", "current_frame_info", ".", "initialized", ")", "return", "current_frame_info", ".", "total_size", "==", "0", ";", "return", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", ".", "This", "allows", "the", "optimizer", "to", "omit", "jumps", "to", "jumps", "if", "no", "stack", "was", "created", "." ]

[ "mips", "0", "31", "0", "4", "0", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "MI", ",", "MRI", ",", "B", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "legalizeFDIV", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "return", "legalizeAtomicCmpXChg", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "\"expected switch to return\"" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "Packet", ".", "clear", "(", ")", ";", "ResourcesModel", "->", "clearResources", "(", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "TPC" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getUndefRegClearance", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "hasUndefRegUpdate", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "0", ";", "OpNum", "=", "1", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "isUndef", "(", ")", "&&", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "return", "16", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "certain", "undef", "register", "reads", "." ]

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

[]

[ "<s>", "static", "void", "s390_init_frame_layout", "(", "void", ")", "{", "HOST_WIDE_INT", "frame_size", ";", "int", "base_used", ";", "gcc_assert", "(", "!", "reload_completed", ")", ";", "if", "(", "!", "TARGET_CPU_ZARCH", ")", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "true", ";", "do", "{", "frame_size", "=", "cfun_frame_layout", ".", "frame_size", ";", "base_used", "=", "cfun", "->", "machine", "->", "split_branches_pending_p", "||", "crtl", "->", "uses_const_pool", "||", "(", "!", "DISP_IN_RANGE", "(", "frame_size", ")", "&&", "!", "CONST_OK_FOR_K", "(", "frame_size", ")", ")", ";", "if", "(", "!", "base_used", ")", "cfun", "->", "machine", "->", "base_reg", "=", "NULL_RTX", ";", "else", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "df_regs_ever_live_p", "(", "5", ")", ")", "cfun", "->", "machine", "->", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "5", ")", ";", "else", "cfun", "->", "machine", "->", "base_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "BASE_REGNUM", ")", ";", "s390_register_info", "(", ")", ";", "s390_frame_info", "(", ")", ";", "}", "while", "(", "frame_size", "!=", "cfun_frame_layout", ".", "frame_size", ")", ";", "}", "</s>" ]

[ "Generate", "frame", "layout", ".", "Fills", "in", "register", "and", "frame", "data", "for", "the", "current", "function", "in", "cfun-", ">", "machine", ".", "This", "routine", "can", "be", "called", "multiple", "times", ";", "it", "will", "re-do", "the", "complete", "frame", "layout", "every", "time", "." ]

[ "s390", "5", "5" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "initialize", "(", "MF", ")", ";", "return", "removeLD", "(", ")", ";", "}", "</s>" ]

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

[ "BPF" ]

[]

[ "<s>", "static", "bool", "loongarch_canonicalize_int_order_test", "(", "enum", "rtx_code", "*", "code", ",", "rtx", "*", "cmp1", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "plus_one", ";", "if", "(", "loongarch_int_order_operand_ok_p", "(", "*", "code", ",", "*", "cmp1", ")", ")", "return", "true", ";", "if", "(", "CONST_INT_P", "(", "*", "cmp1", ")", ")", "switch", "(", "*", "code", ")", "{", "case", "LE", ":", "plus_one", "=", "trunc_int_for_mode", "(", "UINTVAL", "(", "*", "cmp1", ")", "+", "1", ",", "mode", ")", ";", "if", "(", "INTVAL", "(", "*", "cmp1", ")", "<", "plus_one", ")", "{", "*", "code", "=", "LT", ";", "*", "cmp1", "=", "force_reg", "(", "mode", ",", "GEN_INT", "(", "plus_one", ")", ")", ";", "return", "true", ";", "}", "break", ";", "case", "LEU", ":", "plus_one", "=", "trunc_int_for_mode", "(", "UINTVAL", "(", "*", "cmp1", ")", "+", "1", ",", "mode", ")", ";", "if", "(", "plus_one", "!=", "0", ")", "{", "*", "code", "=", "LTU", ";", "*", "cmp1", "=", "force_reg", "(", "mode", ",", "GEN_INT", "(", "plus_one", ")", ")", ";", "return", "true", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "*", "CMP1", "(", "of", "mode", "MODE", ")", "is", "a", "valid", "second", "operand", "for", "integer", "ordering", "test", "*", "CODE", ",", "or", "if", "an", "equivalent", "combination", "can", "be", "formed", "by", "adjusting", "*", "CODE", "and", "*", "CMP1", ".", "When", "returning", "true", ",", "update", "*", "CODE", "and", "*", "CMP1", "with", "the", "chosen", "code", "and", "operand", ",", "otherwise", "leave", "them", "alone", "." ]

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

[]

[ "<s>", "static", "rtx", "frv_expand_voidaccop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "rtx", "op2", ";", "rtx", "op3", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "0", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "op1", "=", "frv_int_to_acc", "(", "icode", ",", "1", ",", "op1", ")", ";", "if", "(", "!", "op1", ")", "return", "NULL_RTX", ";", "op2", "=", "frv_matching_accg_for_acc", "(", "op0", ")", ";", "op3", "=", "frv_matching_accg_for_acc", "(", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ",", "op2", ",", "op3", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "perform", "accumulator-to-accumulator", "operations", ".", "These", "builtins", "take", "two", "accumulator", "numbers", "as", "argument", "and", "return", "void", "." ]

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

[]

[ "<s>", "const", "char", "*", "nds32_output_casesi_pc_relative", "(", "rtx", "*", "operands", ")", "{", "machine_mode", "mode", ";", "rtx", "diff_vec", ";", "diff_vec", "=", "PATTERN", "(", "NEXT_INSN", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "operands", "[", "1", "]", ")", ")", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "diff_vec", ")", "==", "ADDR_DIFF_VEC", ")", ";", "if", "(", "flag_pic", ")", "{", "output_asm_insn", "(", "\"sethi\\t$ta, hi20(%l1@GOTOFF)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"ori\\t$ta, $ta, lo12(%l1@GOTOFF)\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add\\t$ta, $ta, $gp\"", ",", "operands", ")", ";", "}", "else", "output_asm_insn", "(", "\"la\\t$ta, %l1\"", ",", "operands", ")", ";", "mode", "=", "GET_MODE", "(", "diff_vec", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "output_asm_insn", "(", "\"lb\\t%2, [$ta + %0 << 0]\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "output_asm_insn", "(", "\"lh\\t%2, [$ta + %0 << 1]\"", ",", "operands", ")", ";", "break", ";", "case", "E_SImode", ":", "output_asm_insn", "(", "\"lw\\t%2, [$ta + %0 << 2]\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_asm_insn", "(", "\"add\\t$ta, %2, $ta\"", ",", "operands", ")", ";", "if", "(", "TARGET_16_BIT", ")", "return", "\"jr5\\t$ta\"", ";", "else", "return", "\"jr\\t$ta\"", ";", "}", "</s>" ]

[ "Function", "to", "generate", "PC", "relative", "jump", "table", ".", "Refer", "to", "nds32.md", "for", "more", "details", ".", "The", "following", "is", "the", "sample", "for", "the", "case", "that", "diff", "value", "can", "be", "presented", "in", "'.short", "'", "size", ".", "addi", "$", "r1", ",", "$", "r1", ",", "-", "(", "case_lower_bound", ")", "slti", "$", "ta", ",", "$", "r1", ",", "(", "case_number", ")", "beqz", "$", "ta", ",", ".L_skip_label", "la", "$", "ta", ",", ".L35", "!", "get", "jump", "table", "address", "lh", "$", "r1", ",", "[", "$", "ta", "+", "$", "r1", "<", "<", "1", "]", "!", "load", "symbol", "diff", "from", "jump", "table", "entry", "addi", "$", "ta", ",", "$", "r1", ",", "$", "ta", "jr5", "$", "ta", "!", "jump", "table", "entry", "L35", ":", ".short", ".L25-.L35", ".short", ".L26-.L35", ".short", ".L27-.L35", ".short", ".L28-.L35", ".short", ".L29-.L35", ".short", ".L30-.L35", ".short", ".L31-.L35", ".short", ".L32-.L35", ".short", ".L33-.L35", ".short", ".L34-.L35" ]

[ "nds32", "1", "\"sethi\\t$ta, hi20(%l1@GOTOFF)\"", "\"ori\\t$ta, $ta, lo12(%l1@GOTOFF)\"", "\"add\\t$ta, $ta, $gp\"", "\"la\\t$ta, %l1\"", "\"lb\\t%2, [$ta + %0 << 0]\"", "\"lh\\t%2, [$ta + %0 << 1]\"", "\"lw\\t%2, [$ta + %0 << 2]\"", "\"add\\t$ta, %2, $ta\"", "\"jr5\\t$ta\"", "\"jr\\t$ta\"" ]

[]

[ "<s>", "virtual", "const", "Cpu0Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getSize", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", "||", "MI", "->", "isPosition", "(", ")", ")", "return", "0", ";", "unsigned", "Size", "=", "MI", "->", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "if", "(", "!", "Size", ")", "Size", "=", "HEXAGON_INSTR_SIZE", ";", "if", "(", "isConstExtended", "(", "MI", ")", "||", "isExtended", "(", "MI", ")", ")", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "return", "Size", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "in", "the", "encoding", "of", "this", "instruction", ",", "or", "zero", "if", "the", "encoding", "size", "can", "not", "be", "known", "from", "the", "opcode", "." ]

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

[]

[ "<s>", "DecodeStatus", "Cpu0Disassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "VStream", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "IsBigEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableCpu032", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "4" ]

[]

[ "<s>", "static", "rtx", "avr_default_expand_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ",", "xop", "[", "3", "]", ";", "int", "n", ",", "n_args", "=", "call_expr_nargs", "(", "exp", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "gcc_assert", "(", "n_args", ">=", "1", "&&", "n_args", "<=", "3", ")", ";", "if", "(", "target", "==", "NULL_RTX", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", "(", "target", ",", "tmode", ")", ")", "{", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "for", "(", "n", "=", "0", ";", "n", "<", "n_args", ";", "n", "++", ")", "{", "tree", "arg", "=", "CALL_EXPR_ARG", "(", "exp", ",", "n", ")", ";", "rtx", "op", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "VOIDmode", ",", "EXPAND_NORMAL", ")", ";", "machine_mode", "opmode", "=", "GET_MODE", "(", "op", ")", ";", "machine_mode", "mode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "n", "+", "1", "]", ".", "mode", ";", "if", "(", "(", "opmode", "==", "SImode", "||", "opmode", "==", "VOIDmode", ")", "&&", "mode", "==", "HImode", ")", "{", "opmode", "=", "HImode", ";", "op", "=", "gen_lowpart", "(", "HImode", ",", "op", ")", ";", "}", "gcc_assert", "(", "opmode", "==", "mode", "||", "opmode", "==", "VOIDmode", ")", ";", "if", "(", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "n", "+", "1", "]", ".", "predicate", "(", "op", ",", "mode", ")", ")", "op", "=", "copy_to_mode_reg", "(", "mode", ",", "op", ")", ";", "xop", "[", "n", "]", "=", "op", ";", "}", "switch", "(", "n_args", ")", "{", "case", "1", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ",", "xop", "[", "1", "]", ")", ";", "break", ";", "case", "3", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "xop", "[", "0", "]", ",", "xop", "[", "1", "]", ",", "xop", "[", "2", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "pat", "==", "NULL_RTX", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Subroutine", "of", "avr_expand_builtin", "to", "expand", "vanilla", "builtins", "with", "non-void", "result", "and", "1", "...", "3", "arguments", "." ]

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

[]

[ "<s>", "static", "unsigned", "int", "insn_is_load_p", "(", "rtx", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "SET", ")", "{", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "MEM", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "&&", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", "==", "MEM", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "GET_CODE", "(", "body", ")", "!=", "PARALLEL", ")", "return", "0", ";", "rtx", "set", "=", "XVECEXP", "(", "body", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "MEM", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "iff", "INSN", "is", "a", "load", "insn", ",", "including", "permuting", "loads", "that", "represent", "an", "lvxd2x", "instruction", ";", "else", "return", "0", "." ]

[ "powerpcspe", "1", "0", "1", "0", "0", "0", "0", "1", "0" ]

[]

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

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be reloaded into\"", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::VGPR_32RegClass", "0" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "unsigned", "StackAlignOverride", ",", "bool", "is64Bit", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "is64Bit", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Shrink Instructions\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Shrink Instructions\"" ]

[]

[ "<s>", "void", "R600InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "O", ".", "flush", "(", ")", ";", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "static", "const", "struct", "cpu_types", "{", "long", "implver", ";", "long", "amask", ";", "const", "char", "*", "const", "cpu", ";", "}", "cpu_types", "[", "]", "=", "{", "{", "IMPLVER_EV7_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", "|", "AMASK_FIX", "|", "AMASK_CIX", ",", "\"ev67\"", "}", ",", "{", "IMPLVER_EV6_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", "|", "AMASK_FIX", "|", "AMASK_CIX", ",", "\"ev67\"", "}", ",", "{", "IMPLVER_EV6_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", "|", "AMASK_FIX", ",", "\"ev6\"", "}", ",", "{", "IMPLVER_EV5_FAMILY", ",", "AMASK_BWX", "|", "AMASK_MVI", ",", "\"pca56\"", "}", ",", "{", "IMPLVER_EV5_FAMILY", ",", "AMASK_BWX", ",", "\"ev56\"", "}", ",", "{", "IMPLVER_EV5_FAMILY", ",", "0", ",", "\"ev5\"", "}", ",", "{", "IMPLVER_EV4_FAMILY", ",", "0", ",", "\"ev4\"", "}", ",", "{", "0", ",", "0", ",", "NULL", "}", "}", ";", "long", "implver", ";", "long", "amask", ";", "const", "char", "*", "cpu", ";", "int", "i", ";", "if", "(", "argc", "<", "1", ")", "return", "NULL", ";", "if", "(", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "return", "NULL", ";", "implver", "=", "__builtin_alpha_implver", "(", ")", ";", "amask", "=", "__builtin_alpha_amask", "(", "~", "0L", ")", ";", "cpu", "=", "NULL", ";", "for", "(", "i", "=", "0", ";", "cpu_types", "[", "i", "]", ".", "cpu", "!=", "NULL", ";", "i", "++", ")", "if", "(", "implver", "==", "cpu_types", "[", "i", "]", ".", "implver", "&&", "(", "~", "amask", "&", "cpu_types", "[", "i", "]", ".", "amask", ")", "==", "cpu_types", "[", "i", "]", ".", "amask", ")", "{", "cpu", "=", "cpu_types", "[", "i", "]", ".", "cpu", ";", "break", ";", "}", "if", "(", "cpu", "==", "NULL", ")", "return", "NULL", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "cpu", ",", "NULL", ")", ";", "}", "</s>" ]

[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]

[ "alpha", "\"ev67\"", "\"ev67\"", "\"ev6\"", "\"pca56\"", "\"ev56\"", "0", "\"ev5\"", "0", "\"ev4\"", "0", "0", "1", "0", "\"cpu\"", "0", "\"tune\"", "0L", "0", "\"-m\"", "0", "\"=\"" ]

[]

[ "<s>", "static", "rtx", "nios2_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "rtx", "return_rtx", "=", "NULL_RTX", ";", "if", "(", "cum", "->", "regs_used", "<", "NUM_ARG_REGS", ")", "return_rtx", "=", "gen_rtx_REG", "(", "mode", ",", "FIRST_ARG_REGNO", "+", "cum", "->", "regs_used", ")", ";", "return", "return_rtx", ";", "}", "</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", ")", "." ]

[ "nios2" ]

[]

[ "<s>", "unsigned", "postOffset", "(", "unsigned", "LogAlign", "=", "0", ")", "const", "{", "unsigned", "PO", "=", "Offset", "+", "Size", ";", "unsigned", "LA", "=", "std", "::", "max", "(", "unsigned", "(", "PostAlign", ")", ",", "LogAlign", ")", ";", "if", "(", "!", "LA", ")", "return", "PO", ";", "return", "WorstCaseAlign", "(", "PO", ",", "LA", ",", "internalKnownBits", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "0" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "Ty", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", "||", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "unsigned", "EltWidth", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "return", "(", "(", "EltWidth", "==", "32", "&&", "Alignment", ">=", "4", ")", "||", "(", "EltWidth", "==", "16", "&&", "Alignment", ">=", "2", ")", "||", "EltWidth", "==", "8", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

[ "ARM", "ARM", "32", "4", "16", "2", "8" ]

[]

[ "<s>", "bool", "rs6000_pcrel_p", "(", ")", "{", "return", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "(", "rs6000_isa_flags", "&", "OPTION_MASK_PCREL", ")", "!=", "0", "&&", "TARGET_CMODEL", "==", "CMODEL_MEDIUM", ")", ";", "}", "</s>" ]

[ "Return", "whether", "we", "should", "generate", "PC-relative", "code", "for", "the", "current", "function", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "bool", "SPScheduler", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "if", "(", "!", "mf", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", "->", "isSinglePath", "(", ")", ")", "{", "return", "false", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SPScheduler on function '\"", "<<", "mf", ".", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "auto", "reduceAnalysis", "=", "&", "getAnalysis", "<", "PatmosSPReduce", ">", "(", ")", ";", "auto", "rootScope", "=", "reduceAnalysis", "->", "RootScope", ";", "for", "(", "auto", "mbbIter", "=", "mf", ".", "begin", "(", ")", ",", "mbbEnd", "=", "mf", ".", "end", "(", ")", ";", "mbbIter", "!=", "mbbEnd", ";", "mbbIter", "++", ")", "{", "auto", "mbb", "=", "&", "(", "*", "mbbIter", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB: [\"", "<<", "mbb", "<<", "\"]: #\"", "<<", "mbb", "->", "getNumber", "(", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "auto", "instrIter", "=", "mbb", "->", "begin", "(", ")", ",", "instrEnd", "=", "mbb", "->", "end", "(", ")", ";", "instrIter", "!=", "instrEnd", ";", "instrIter", "++", ")", "{", "SPInstructions", "++", ";", "calculateLatency", "(", "instrIter", ")", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"AFTER Single-Path Schedule\\n\"", ";", "mf", ".", "dump", "(", ")", ")", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Scope tree after scheduling:\\n\"", ";", "rootScope", "->", "dump", "(", "dbgs", "(", ")", ",", "0", ",", "true", ")", ";", "}", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"Running SPScheduler on function '\"", "\"'\\n\"", "Patmos", "\"MBB: [\"", "\"]: #\"", "\"\\n\"", "\"AFTER Single-Path Schedule\\n\"", "\"Scope tree after scheduling:\\n\"", "0" ]

[]

[ "<s>", "const", "char", "*", "emit_fusion_p9_load", "(", "rtx", "reg", ",", "rtx", "mem", ",", "rtx", "tmp_reg", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "load_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "FLOAT_EXTEND", "||", "GET_CODE", "(", "mem", ")", "==", "ZERO_EXTEND", ")", "{", "mem", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_load, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "load_string", "=", "\"lfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "load_string", "=", "\"lfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "load_string", "=", "\"lbz\"", ";", "break", ";", "case", "HImode", ":", "load_string", "=", "\"lhz\"", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "load_string", "=", "\"lwz\"", ";", "break", ";", "case", "DImode", ":", "case", "DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "load_string", "=", "\"ld\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_load, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_load not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ",", "\"power9 load fusion\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "load_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "load", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "rs6000", "0", "0", "\"emit_fusion_p9_load, bad reg #1\"", "\"lfs\"", "\"lfd\"", "\"lbz\"", "\"lhz\"", "\"lwz\"", "\"ld\"", "\"emit_fusion_p9_load, bad reg #2\"", "\"emit_fusion_p9_load not MEM\"", "0", "\"power9 load fusion\"", "\"\"" ]

[]

[ "<s>", "const", "uint16_t", "*", "NVPTXRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0" ]

[]

[ "<s>", "ix86_dependencies_evaluation_hook", "static", "int", "ix86_reassociation_width", "(", "unsigned", "int", "op", ",", "machine_mode", "mode", ")", "{", "int", "width", "=", "1", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "int", "div", "=", "1", ";", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "width", "=", "ix86_cost", "->", "reassoc_vec_int", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "width", "=", "ix86_cost", "->", "reassoc_vec_fp", ";", "if", "(", "width", "==", "1", ")", "return", "1", ";", "if", "(", "ix86_tune", "==", "PROCESSOR_ZNVER1", "&&", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "op", "!=", "PLUS", "&&", "op", "!=", "MINUS", ")", "return", "1", ";", "if", "(", "TARGET_AVX128_OPTIMAL", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "128", ")", "div", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "128", ";", "else", "if", "(", "TARGET_SSE_SPLIT_REGS", "&&", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "64", ")", "div", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "64", ";", "width", "=", "(", "width", "+", "div", "-", "1", ")", "/", "div", ";", "}", "else", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", ")", "width", "=", "ix86_cost", "->", "reassoc_int", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "width", "=", "ix86_cost", "->", "reassoc_fp", ";", "if", "(", "!", "TARGET_64BIT", "&&", "width", ">", "2", ")", "width", "=", "2", ";", "return", "width", ";", "}", "</s>" ]

[ "Implementation", "of", "reassociation_width", "target", "hook", "used", "by", "reassoc", "phase", "to", "identify", "parallelism", "level", "in", "reassociated", "tree", ".", "Statements", "tree_code", "is", "passed", "in", "OPC", ".", "Arguments", "type", "is", "passed", "in", "MODE", ".", "Currently", "parallel", "reassociation", "is", "enabled", "for", "Atom", "processors", "only", "and", "we", "set", "reassociation", "width", "to", "be", "2", "because", "Atom", "may", "issue", "up", "to", "2", "instructions", "per", "cycle", ".", "Return", "value", "should", "be", "fixed", "if", "parallel", "reassociation", "is", "enabled", "for", "other", "processors", "." ]

[ "i386", "1", "1", "1", "1", "1", "128", "128", "64", "64", "1", "2", "2" ]

[]

[ "<s>", "bool", "SICAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "MCOp", "=", "MCInstLowering", ".", "LowerOperand", "(", "MO", ")", ";", "return", "MCOp", ".", "isValid", "(", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "void", "emitBundleAlignMode", "(", "unsigned", "AlignPow2", ")", "override", "{", "}", "</s>" ]

[ "Set", "the", "bundle", "alignment", "mode", "from", "now", "on", "in", "the", "section", "." ]

[ "Patmos" ]

[]

[ "<s>", "const", "Z80oldSubtarget", "*", "Z80oldTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "true", ";", "if", "(", "SoftFloat", ")", "{", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "}", "unsigned", "CPUFSWidth", "=", "Key", ".", "size", "(", ")", ";", "FS", "=", "Key", ".", "slice", "(", "CPU", ".", "size", "(", ")", ",", "CPUFSWidth", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "Z80oldSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "Z80old", "\"target-cpu\"", "\"target-features\"", "512", "\"+soft-float\"", "\",+soft-float\"", "Z80old" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "LowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "lowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "lowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAP", ":", "return", "lowerTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DEBUGTRAP", ":", "return", "lowerDEBUGTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "case", "ISD", "::", "FCANONICALIZE", ":", "return", "splitUnaryVectorOp", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "return", "lowerFMINNUM_FMAXNUM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "SMIN", ":", "case", "ISD", "::", "SMAX", ":", "case", "ISD", "::", "UMIN", ":", "case", "ISD", "::", "UMAX", ":", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "FMUL", ":", "case", "ISD", "::", "FMINNUM_IEEE", ":", "case", "ISD", "::", "FMAXNUM_IEEE", ":", "return", "splitBinaryVectorOp", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "ISD::BRCOND", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_W_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI", "ISD::ADDRSPACECAST", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::FP_ROUND", "ISD::TRAP", "ISD::DEBUGTRAP", "ISD::FABS", "ISD::FNEG", "ISD::FCANONICALIZE", "ISD::FMINNUM", "ISD::FMAXNUM", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ADD", "ISD::SUB", "ISD::MUL", "ISD::SMIN", "ISD::SMAX", "ISD::UMIN", "ISD::UMAX", "ISD::FADD", "ISD::FMUL", "ISD::FMINNUM_IEEE", "ISD::FMAXNUM_IEEE" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AMDGPUTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "RMW", ")", "const", "{", "switch", "(", "RMW", "->", "getOperation", "(", ")", ")", "{", "case", "AtomicRMWInst", "::", "Nand", ":", "case", "AtomicRMWInst", "::", "FAdd", ":", "case", "AtomicRMWInst", "::", "FSub", ":", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "default", ":", "return", "AtomicExpansionKind", "::", "None", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "if", "(", "isTailCall", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "DAG", ")", ";", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", ")", "{", "if", "(", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "LowerCall_64SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "else", "return", "LowerCall_32SVR4", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "return", "LowerCall_Darwin", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OutputArg", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "is64bit", ")", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes_64", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR_64", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "else", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX::Int64RegsRegClass", "NVPTX::cvta_local_yes_64", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR_64", "NVPTX::Int32RegsRegClass", "NVPTX::cvta_local_yes", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR" ]

[]

[ "<s>", "void", "setMBB", "(", "MachineBasicBlock", "*", "MBBv", ")", "{", "MBB", "=", "MBBv", ";", "}", "</s>" ]

[ "Set", "the", "insertion", "point", "to", "the", "end", "of", "MBB", "." ]

[ "TVM" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "EmitA64MappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "JTI", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "II", "=", "(", "(", "const", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "const", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "Subtarget", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "0", ";", "if", "(", "MF", ".", "getJumpTableInfo", "(", ")", ")", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "IsThumb", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", "->", "isThumbFunction", "(", ")", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "MMI", "=", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ";", "MCE", ".", "setModuleInfo", "(", "MMI", ")", ";", "do", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ")", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "ARM", "0", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "unsigned", "M88kIncomingValueHandler", "::", "assignCustomValue", "(", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ",", "std", "::", "function", "<", "void", "(", ")", ">", "*", "Thunk", ")", "{", "assert", "(", "Arg", ".", "Regs", ".", "size", "(", ")", "==", "1", "&&", "\"Can't handle multple regs yet\"", ")", ";", "CCValAssign", "VA", "=", "VAs", "[", "0", "]", ";", "assert", "(", "VA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "!=", "MVT", "::", "f64", ")", "return", "0", ";", "CCValAssign", "NextVA", "=", "VAs", "[", "1", "]", ";", "assert", "(", "NextVA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "NextVA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "assert", "(", "VA", ".", "getValNo", "(", ")", "==", "NextVA", ".", "getValNo", "(", ")", "&&", "\"Values belong to different arguments\"", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "assert", "(", "NextVA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "Register", "NewRegs", "[", "]", "=", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ",", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", "}", ";", "assignValueToReg", "(", "NewRegs", "[", "0", "]", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ")", ";", "assignValueToReg", "(", "NewRegs", "[", "1", "]", ",", "NextVA", ".", "getLocReg", "(", ")", ",", "NextVA", ")", ";", "MIRBuilder", ".", "buildMerge", "(", "Arg", ".", "Regs", "[", "0", "]", ",", "NewRegs", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Handle", "custom", "values", ",", "which", "may", "be", "passed", "into", "one", "or", "more", "of", "VAs", "." ]

[ "M88k", "M88k", "1", "\"Can't handle multple regs yet\"", "0", "\"Value doesn't need custom handling\"", "MVT::f64", "0", "1", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "\"Values belong to different arguments\"", "\"Value should be in reg\"", "\"Value should be in reg\"", "32", "32", "0", "1", "0", "1" ]

[]

[ "<s>", "rtx", "loongarch_unspec_address", "(", "rtx", "address", ",", "enum", "loongarch_symbol_type", "symbol_type", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "address", ",", "&", "base", ",", "&", "offset", ")", ";", "return", "loongarch_unspec_address_offset", "(", "base", ",", "offset", ",", "symbol_type", ")", ";", "}", "</s>" ]

[ "Return", "an", "UNSPEC", "address", "with", "underlying", "address", "ADDRESS", "and", "symbol", "type", "SYMBOL_TYPE", "." ]

[ "loongarch" ]

[]

[ "<s>", "const", "char", "*", "ARCompactTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "ARCISD", "::", "CALL", ":", "return", "\"ARCISD::CALL\"", ";", "case", "ARCISD", "::", "CMP", ":", "return", "\"ARCISD::CMP\"", ";", "case", "ARCISD", "::", "BR_CC", ":", "return", "\"ARCISD::BR_CC\"", ";", "case", "ARCISD", "::", "SELECT_CC", ":", "return", "\"ARCISD::SELECT_CC\"", ";", "case", "ARCISD", "::", "Wrapper", ":", "return", "\"ARCISD::Wrapper\"", ";", "case", "ARCISD", "::", "RET_FLAG", ":", "return", "\"ARCISD::RET_FLAG\"", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

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

[ "ARCompact", "ARC", "ARCISD::CALL", "\"ARCISD::CALL\"", "ARCISD::CMP", "\"ARCISD::CMP\"", "ARCISD::BR_CC", "\"ARCISD::BR_CC\"", "ARCISD::SELECT_CC", "\"ARCISD::SELECT_CC\"", "ARCISD::Wrapper", "\"ARCISD::Wrapper\"", "ARCISD::RET_FLAG", "\"ARCISD::RET_FLAG\"", "0" ]

[]

[ "<s>", "void", "A57ChainingConstraint", "::", "apply", "(", "PBQPRAGraph", "&", "G", ")", "{", "const", "MachineFunction", "&", "MF", "=", "G", ".", "getMetadata", "(", ")", ".", "MF", ";", "LiveIntervals", "&", "LIs", "=", "G", ".", "getMetadata", "(", ")", ".", "LIS", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "MBB", ":", "MF", ")", "{", "Chains", ".", "clear", "(", ")", ";", "for", "(", "const", "auto", "&", "MI", ":", "MBB", ")", "{", "for", "(", "auto", "r", ":", "Chains", ")", "{", "SmallVector", "<", "unsigned", ",", "8", ">", "toDel", ";", "if", "(", "regJustKilledBefore", "(", "LIs", ",", "r", ",", "MI", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Killing chain \"", "<<", "printReg", "(", "r", ",", "TRI", ")", "<<", "\" at \"", ";", "MI", ".", "print", "(", "dbgs", "(", ")", ")", ";", ")", ";", "toDel", ".", "push_back", "(", "r", ")", ";", "}", "while", "(", "!", "toDel", ".", "empty", "(", ")", ")", "{", "Chains", ".", "remove", "(", "toDel", ".", "back", "(", ")", ")", ";", "toDel", ".", "pop_back", "(", ")", ";", "}", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AArch64", "::", "FMSUBSrrr", ":", "case", "AArch64", "::", "FMADDSrrr", ":", "case", "AArch64", "::", "FNMSUBSrrr", ":", "case", "AArch64", "::", "FNMADDSrrr", ":", "case", "AArch64", "::", "FMSUBDrrr", ":", "case", "AArch64", "::", "FMADDDrrr", ":", "case", "AArch64", "::", "FNMSUBDrrr", ":", "case", "AArch64", "::", "FNMADDDrrr", ":", "{", "Register", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "Ra", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "if", "(", "addIntraChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ")", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Ra", ")", ";", "break", ";", "}", "case", "AArch64", "::", "FMLAv2f32", ":", "case", "AArch64", "::", "FMLSv2f32", ":", "{", "Register", "Rd", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "addInterChainConstraint", "(", "G", ",", "Rd", ",", "Rd", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AArch64", "8", "\"Killing chain \"", "\" at \"", "AArch64::FMSUBSrrr", "AArch64::FMADDSrrr", "AArch64::FNMSUBSrrr", "AArch64::FNMADDSrrr", "AArch64::FMSUBDrrr", "AArch64::FMADDDrrr", "AArch64::FNMSUBDrrr", "AArch64::FNMADDDrrr", "0", "3", "AArch64::FMLAv2f32", "AArch64::FMLSv2f32", "0" ]

[]

[ "<s>", "static", "tree", "s390_expand_overloaded_builtin", "(", "location_t", "loc", ",", "unsigned", "fcode", ",", "vec", "<", "tree", ",", "va_gc", ">", "*", "arglist", ",", "tree", "return_type", ")", "{", "switch", "(", "fcode", ")", "{", "case", "S390_OVERLOADED_BUILTIN_s390_vec_step", ":", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ")", "!=", "VECTOR_TYPE", ")", "{", "error_at", "(", "loc", ",", "\"Builtin vec_step can only be used on vector types.\"", ")", ";", "return", "error_mark_node", ";", "}", "return", "build_int_cst", "(", "NULL_TREE", ",", "TYPE_VECTOR_SUBPARTS", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ")", ")", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xld2", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xlw4", ":", "return", "build2", "(", "MEM_REF", ",", "return_type", ",", "fold_build_pointer_plus", "(", "(", "*", "arglist", ")", "[", "1", "]", ",", "(", "*", "arglist", ")", "[", "0", "]", ")", ",", "build_int_cst", "(", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "1", "]", ")", ",", "0", ")", ")", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xstd2", ":", "case", "S390_OVERLOADED_BUILTIN_s390_vec_xstw4", ":", "return", "build2", "(", "MODIFY_EXPR", ",", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ",", "build1", "(", "INDIRECT_REF", ",", "TREE_TYPE", "(", "(", "*", "arglist", ")", "[", "0", "]", ")", ",", "fold_build_pointer_plus", "(", "(", "*", "arglist", ")", "[", "2", "]", ",", "(", "*", "arglist", ")", "[", "1", "]", ")", ")", ",", "(", "*", "arglist", ")", "[", "0", "]", ")", ";", "case", "S390_OVERLOADED_BUILTIN_s390_vec_load_pair", ":", "return", "build_constructor_va", "(", "return_type", ",", "2", ",", "NULL_TREE", ",", "(", "*", "arglist", ")", "[", "0", "]", ",", "NULL_TREE", ",", "(", "*", "arglist", ")", "[", "1", "]", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Expand", "builtins", "which", "can", "directly", "be", "mapped", "to", "tree", "expressions", ".", "LOC", "-", "location", "information", "FCODE", "-", "function", "code", "of", "the", "builtin", "ARGLIST", "-", "value", "supposed", "to", "be", "passed", "as", "arguments", "RETURN-TYPE", "-", "expected", "return", "type", "of", "the", "builtin" ]

[ "s390", "0", "\"Builtin vec_step can only be used on vector types.\"", "0", "1", "0", "1", "0", "0", "0", "2", "1", "0", "2", "0", "1" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "void", "MOSTargetMachine", "::", "registerPassBuilderCallbacks", "(", "PassBuilder", "&", "PB", ")", "{", "PB", ".", "registerPipelineParsingCallback", "(", "[", "]", "(", "StringRef", "Name", ",", "LoopPassManager", "&", "PM", ",", "ArrayRef", "<", "PassBuilder", "::", "PipelineElement", ">", ")", "{", "if", "(", "Name", "==", "\"mos-indexiv\"", ")", "{", "PM", ".", "addPass", "(", "MOSIndexIV", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ")", ";", "PB", ".", "registerLateLoopOptimizationsEPCallback", "(", "[", "]", "(", "LoopPassManager", "&", "PM", ",", "OptimizationLevel", "Level", ")", "{", "if", "(", "Level", "!=", "OptimizationLevel", "::", "O0", ")", "{", "PM", ".", "addPass", "(", "MOSIndexIV", "(", ")", ")", ";", "PM", ".", "addPass", "(", "IndVarSimplifyPass", "(", ")", ")", ";", "}", "}", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS", "\"mos-indexiv\"", "MOS", "MOS" ]

[]

[ "<s>", "int", "first_fp_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "14", "+", "32", ";", "first_reg", "<=", "63", ";", "first_reg", "++", ")", "if", "(", "regs_ever_live", "[", "first_reg", "]", ")", "break", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Similar", ",", "for", "FP", "regs", "." ]

[ "rs6000", "14", "32", "63" ]

[]

[ "<s>", "int", "mcore_is_dead", "(", "rtx", "first", ",", "rtx", "reg", ")", "{", "rtx", "insn", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "if", "(", "dead_or_set_p", "(", "first", ",", "reg", ")", ")", "return", "1", ";", "for", "(", "insn", "=", "NEXT_INSN", "(", "first", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", ")", "return", "0", ";", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", "{", "if", "(", "reg_referenced_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", "||", "find_reg_fusage", "(", "insn", ",", "USE", ",", "reg", ")", ")", "return", "0", ";", "else", "if", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", ")", "return", "1", ";", "}", "else", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", ")", "{", "if", "(", "reg_referenced_p", "(", "reg", ",", "PATTERN", "(", "insn", ")", ")", ")", "return", "0", ";", "else", "if", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Check", "whether", "reg", "is", "dead", "at", "first", ".", "This", "is", "done", "by", "searching", "ahead", "for", "either", "the", "next", "use", "(", "i.e.", ",", "reg", "is", "live", ")", ",", "a", "death", "note", ",", "or", "a", "set", "of", "reg", ".", "Do", "n't", "just", "use", "dead_or_set_p", "(", ")", "since", "reload", "does", "not", "always", "mark", "deaths", "(", "especially", "if", "PRESERVE_DEATH_NOTES_REGNO_P", "is", "not", "defined", ")", ".", "We", "can", "ignore", "subregs", "by", "extracting", "the", "actual", "register", ".", "BRC" ]

[ "mcore", "1", "0", "0", "1", "0", "1", "0" ]

[]

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

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

[ "OR1K", "OR1K", "4", "0", "0", "4", "0x15000000" ]

[]

[ "<s>", "static", "reg_class_t", "reduce_class", "(", "reg_class_t", "original_class", ",", "reg_class_t", "limiting_class", ",", "reg_class_t", "returned_if_empty", ")", "{", "HARD_REG_SET", "cc", ";", "int", "i", ";", "reg_class_t", "best", "=", "NO_REGS", ";", "unsigned", "int", "best_size", "=", "0", ";", "if", "(", "original_class", "==", "limiting_class", ")", "return", "original_class", ";", "cc", "=", "reg_class_contents", "[", "original_class", "]", ";", "AND_HARD_REG_SET", "(", "cc", ",", "reg_class_contents", "[", "limiting_class", "]", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "LIM_REG_CLASSES", ";", "i", "++", ")", "{", "if", "(", "hard_reg_set_subset_p", "(", "reg_class_contents", "[", "i", "]", ",", "cc", ")", ")", "if", "(", "best_size", "<", "reg_class_size", "[", "i", "]", ")", "{", "best", "=", "(", "reg_class_t", ")", "i", ";", "best_size", "=", "reg_class_size", "[", "i", "]", ";", "}", "}", "if", "(", "best", "==", "NO_REGS", ")", "return", "returned_if_empty", ";", "return", "best", ";", "}", "</s>" ]

[ "Given", "two", "register", "classes", ",", "find", "the", "largest", "intersection", "between", "them", ".", "If", "there", "is", "no", "intersection", ",", "return", "RETURNED_IF_EMPTY", "instead", "." ]

[ "m32c", "0", "0" ]

[]

[ "<s>", "static", "bool", "use_vfp_abi", "(", "enum", "arm_pcs", "pcs_variant", ",", "bool", "is_double", ")", "{", "if", "(", "pcs_variant", "==", "ARM_PCS_AAPCS_VFP", ")", "{", "static", "bool", "seen_thumb1_vfp", "=", "false", ";", "if", "(", "TARGET_THUMB1", "&&", "!", "seen_thumb1_vfp", ")", "{", "sorry", "(", "\"Thumb-1 hard-float VFP ABI\"", ")", ";", "seen_thumb1_vfp", "=", "true", ";", "}", "return", "true", ";", "}", "if", "(", "pcs_variant", "!=", "ARM_PCS_AAPCS_LOCAL", ")", "return", "false", ";", "return", "(", "TARGET_32BIT", "&&", "TARGET_VFP", "&&", "TARGET_HARD_FLOAT", "&&", "(", "TARGET_VFP_DOUBLE", "||", "!", "is_double", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "PCS_VARIANT", "should", "use", "VFP", "registers", "." ]

[ "arm", "\"Thumb-1 hard-float VFP ABI\"" ]

[]

[ "<s>", "bool", "isKMergeMasked", "(", ")", "const", "{", "return", "(", "Attributes", "&", "KMergeMasked", ")", "!=", "0", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "group", "of", "FMA", "opcodes", "holds", "k-merge-masked", "opcodes", "." ]

[ "X86", "0" ]

[]

[ "<s>", "bool", "partialVCCWritesUpdateVCCZ", "(", ")", "const", "{", "return", "getGeneration", "(", ")", ">=", "GFX10", ";", "}", "</s>" ]

[ "Writes", "to", "VCC_LO/VCC_HI", "update", "the", "VCCZ", "flag", "." ]

[ "AMDGPU" ]

[]

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

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

[ "RI5CY", "\"RISCV DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "mips_output_function_prologue", "(", "FILE", "*", "file", ")", "{", "const", "char", "*", "fnname", ";", "if", "(", "TARGET_MIPS16", "&&", "TARGET_HARD_FLOAT_ABI", "&&", "crtl", "->", "args", ".", "info", ".", "fp_code", "!=", "0", ")", "mips16_build_function_stub", "(", ")", ";", "fnname", "=", "XSTR", "(", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ",", "0", ")", ";", "mips_start_function_definition", "(", "fnname", ",", "TARGET_MIPS16", ")", ";", "if", "(", "!", "flag_inhibit_size_directive", ")", "{", "const", "struct", "mips_frame_info", "*", "frame", ";", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "fprintf", "(", "file", ",", "\"\\t.frame\\t%s,\"", "HOST_WIDE_INT_PRINT_DEC", "\",%s\\t\\t\"", "\"# vars= \"", "HOST_WIDE_INT_PRINT_DEC", "\", regs= %d/%d\"", "\", args= \"", "HOST_WIDE_INT_PRINT_DEC", "\", gp= \"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "reg_names", "[", "frame_pointer_needed", "?", "HARD_FRAME_POINTER_REGNUM", ":", "STACK_POINTER_REGNUM", "]", ",", "(", "frame_pointer_needed", "?", "frame", "->", "total_size", "-", "frame", "->", "hard_frame_pointer_offset", ":", "frame", "->", "total_size", ")", ",", "reg_names", "[", "RETURN_ADDR_REGNUM", "]", ",", "frame", "->", "var_size", ",", "frame", "->", "num_gp", ",", "frame", "->", "num_fp", ",", "frame", "->", "args_size", ",", "frame", "->", "cprestore_size", ")", ";", "fprintf", "(", "file", ",", "\"\\t.mask\\t0x%08x,\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "frame", "->", "mask", ",", "frame", "->", "gp_save_offset", ")", ";", "fprintf", "(", "file", ",", "\"\\t.fmask\\t0x%08x,\"", "HOST_WIDE_INT_PRINT_DEC", "\"\\n\"", ",", "frame", "->", "fmask", ",", "frame", "->", "fp_save_offset", ")", ";", "}", "if", "(", "mips_must_initialize_gp_p", "(", ")", "&&", "mips_current_loadgp_style", "(", ")", "==", "LOADGP_OLDABI", ")", "{", "if", "(", "TARGET_MIPS16", ")", "{", "output_asm_insn", "(", "\"li\\t$2,%%hi(_gp_disp)\"", ",", "0", ")", ";", "output_asm_insn", "(", "\"addiu\\t$3,$pc,%%lo(_gp_disp)\"", ",", "0", ")", ";", "output_asm_insn", "(", "\"sll\\t$2,16\"", ",", "0", ")", ";", "output_asm_insn", "(", "\"addu\\t$2,$3\"", ",", "0", ")", ";", "}", "else", "{", "mips_push_asm_switch", "(", "&", "mips_noreorder", ")", ";", "output_asm_insn", "(", "\".cpload\\t%^\"", ",", "0", ")", ";", "if", "(", "!", "cfun", "->", "machine", "->", "all_noreorder_p", ")", "mips_pop_asm_switch", "(", "&", "mips_noreorder", ")", ";", "else", "mips_push_asm_switch", "(", "&", "mips_nomacro", ")", ";", "}", "}", "else", "if", "(", "cfun", "->", "machine", "->", "all_noreorder_p", ")", "{", "mips_push_asm_switch", "(", "&", "mips_noreorder", ")", ";", "mips_push_asm_switch", "(", "&", "mips_nomacro", ")", ";", "}", "mips_output_cplocal", "(", ")", ";", "}", "</s>" ]

[ "Set", "up", "the", "stack", "and", "frame", "(", "if", "desired", ")", "for", "the", "function", "." ]

[ "mips", "0", "0", "0", "\"\\t.frame\\t%s,\"", "\",%s\\t\\t\"", "\"# vars= \"", "\", regs= %d/%d\"", "\", args= \"", "\", gp= \"", "\"\\n\"", "\"\\t.mask\\t0x%08x,\"", "\"\\n\"", "\"\\t.fmask\\t0x%08x,\"", "\"\\n\"", "\"li\\t$2,%%hi(_gp_disp)\"", "0", "\"addiu\\t$3,$pc,%%lo(_gp_disp)\"", "0", "\"sll\\t$2,16\"", "0", "\"addu\\t$2,$3\"", "0", "\".cpload\\t%^\"", "0" ]

[]

[ "<s>", "bool", "AArch64A57FPLoadBalancing", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A57FPLoadBalancing *****\\n\"", ")", ";", "const", "TargetMachine", "&", "TM", "=", "F", ".", "getTarget", "(", ")", ";", "MRI", "=", "&", "F", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "F", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "TII", "=", "TM", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "RCI", ".", "runOnMachineFunction", "(", "F", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64A57FPLoadBalancing *****\\n\"", "AArch64" ]

[]

[ "<s>", "TargetTransformInfo", "NVPTXTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "NVPTXTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getFnAttributes", "(", ")", ".", "hasNoRedZoneAttr", "(", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "(", "Subtarget", ".", "isPPC64", "(", ")", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "spillsCR", "(", "MF", ")", ")", "&&", "(", "!", "ALIGN_STACK", "||", "MaxAlign", "<=", "TargetAlign", ")", ")", "{", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "PowerPC", "PPC", "1", "224", "PPC", "0", "PPC" ]

[]

[ "<s>", "bool", "nds32_n9_2r1w_mm_to_ex_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "rtx", "def_reg", ";", "switch", "(", "get_attr_type", "(", "producer", ")", ")", "{", "case", "TYPE_LOAD", ":", "if", "(", "post_update_insn_p", "(", "producer", ")", ")", "return", "false", ";", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "case", "TYPE_MUL", ":", "case", "TYPE_MAC", ":", "def_reg", "=", "SET_DEST", "(", "PATTERN", "(", "producer", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "n9_2r1w_consumed_by_ex_dep_p", "(", "consumer", ",", "def_reg", ")", ";", "}", "</s>" ]

[ "Check", "dependencies", "from", "MM", "to", "EX", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "CopyGeneration", "::", "processBlock", "(", "MachineBasicBlock", "&", "B", ",", "const", "RegisterSet", "&", "AVs", ")", "{", "if", "(", "!", "BT", ".", "reached", "(", "&", "B", ")", ")", "return", "false", ";", "RegisterSet", "AVB", "(", "AVs", ")", ";", "bool", "Changed", "=", "false", ";", "RegisterSet", "Defs", ";", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ",", "NextI", "=", "I", ";", "I", "!=", "E", ";", "++", "I", ",", "AVB", ".", "insert", "(", "Defs", ")", ")", "{", "NextI", "=", "std", "::", "next", "(", "I", ")", ";", "Defs", ".", "clear", "(", ")", ";", "HBS", "::", "getInstrDefs", "(", "*", "I", ",", "Defs", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "CopyPropagation", "::", "isCopyReg", "(", "Opc", ",", "false", ")", "||", "ConstGeneration", "::", "isTfrConst", "(", "*", "I", ")", ")", "continue", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "auto", "At", "=", "I", "->", "isPHI", "(", ")", "?", "B", ".", "getFirstNonPHI", "(", ")", ":", "I", ";", "for", "(", "unsigned", "R", "=", "Defs", ".", "find_first", "(", ")", ";", "R", ";", "R", "=", "Defs", ".", "find_next", "(", "R", ")", ")", "{", "BitTracker", "::", "RegisterRef", "MR", ";", "auto", "*", "FRC", "=", "HBS", "::", "getFinalVRegClass", "(", "R", ",", "MRI", ")", ";", "if", "(", "findMatch", "(", "R", ",", "MR", ",", "AVB", ")", ")", "{", "unsigned", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "FRC", ")", ";", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewR", ")", ".", "addReg", "(", "MR", ".", "Reg", ",", "0", ",", "MR", ".", "Sub", ")", ";", "BT", ".", "put", "(", "BitTracker", "::", "RegisterRef", "(", "NewR", ")", ",", "BT", ".", "get", "(", "MR", ")", ")", ";", "HBS", "::", "replaceReg", "(", "R", ",", "NewR", ",", "MRI", ")", ";", "Forbidden", ".", "insert", "(", "R", ")", ";", "continue", ";", "}", "if", "(", "FRC", "==", "&", "Hexagon", "::", "DoubleRegsRegClass", "||", "FRC", "==", "&", "Hexagon", "::", "VecDblRegsRegClass", "||", "FRC", "==", "&", "Hexagon", "::", "VecDblRegs128BRegClass", ")", "{", "BitTracker", "::", "RegisterRef", "TL", "=", "{", "R", ",", "Hexagon", "::", "subreg_loreg", "}", ";", "BitTracker", "::", "RegisterRef", "TH", "=", "{", "R", ",", "Hexagon", "::", "subreg_hireg", "}", ";", "BitTracker", "::", "RegisterRef", "ML", ",", "MH", ";", "if", "(", "findMatch", "(", "TL", ",", "ML", ",", "AVB", ")", "&&", "findMatch", "(", "TH", ",", "MH", ",", "AVB", ")", ")", "{", "auto", "*", "FRC", "=", "HBS", "::", "getFinalVRegClass", "(", "R", ",", "MRI", ")", ";", "unsigned", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "FRC", ")", ";", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "NewR", ")", ".", "addReg", "(", "ML", ".", "Reg", ",", "0", ",", "ML", ".", "Sub", ")", ".", "addImm", "(", "Hexagon", "::", "subreg_loreg", ")", ".", "addReg", "(", "MH", ".", "Reg", ",", "0", ",", "MH", ".", "Sub", ")", ".", "addImm", "(", "Hexagon", "::", "subreg_hireg", ")", ";", "BT", ".", "put", "(", "BitTracker", "::", "RegisterRef", "(", "NewR", ")", ",", "BT", ".", "get", "(", "R", ")", ")", ";", "HBS", "::", "replaceReg", "(", "R", ",", "NewR", ",", "MRI", ")", ";", "Forbidden", ".", "insert", "(", "R", ")", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "Hexagon", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::VecDblRegsRegClass", "Hexagon::VecDblRegs128BRegClass", "Hexagon::subreg_loreg", "Hexagon::subreg_hireg", "0", "Hexagon::subreg_loreg", "0", "Hexagon::subreg_hireg" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "const", "CallLowering", "::", "ArgInfo", "&", "Arg", ",", "Register", "Addr", ",", "uint64_t", "MemSize", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "Register", "ValVReg", "=", "VA", ".", "getLocInfo", "(", ")", "!=", "CCValAssign", "::", "LocInfo", "::", "FPExt", "?", "extendRegister", "(", "Arg", ".", "Regs", "[", "0", "]", ",", "VA", ")", ":", "Arg", ".", "Regs", "[", "0", "]", ";", "const", "LLT", "RegTy", "=", "MRI", ".", "getType", "(", "ValVReg", ")", ";", "MemSize", "=", "std", "::", "min", "(", "MemSize", ",", "(", "uint64_t", ")", "RegTy", ".", "getSizeInBytes", "(", ")", ")", ";", "assignValueToAddress", "(", "ValVReg", ",", "Addr", ",", "MemSize", ",", "MPO", ",", "VA", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "SystemZFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "int64_t", "Offset", "=", "TargetFrameLowering", "::", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "return", "Offset", "+", "SystemZMC", "::", "CallFrameSize", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZMC::CallFrameSize" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "moxie_init_machine_status", "(", "void", ")", "{", "return", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "}", "</s>" ]

[ "Zero", "initialization", "is", "OK", "for", "all", "current", "fields", "." ]

[ "moxie" ]

[]

[ "<s>", "bool", "NVPTXImageOptimizer", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "InstrToDelete", ".", "clear", "(", ")", ";", "for", "(", "Function", "::", "iterator", "BI", "=", "F", ".", "begin", "(", ")", ",", "BE", "=", "F", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "(", "*", "BI", ")", ".", "begin", "(", ")", ",", "E", "=", "(", "*", "BI", ")", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Instruction", "&", "Instr", "=", "*", "I", ";", "if", "(", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "I", ")", ")", "{", "Function", "*", "CalledF", "=", "CI", "->", "getCalledFunction", "(", ")", ";", "if", "(", "CalledF", "&&", "CalledF", "->", "isIntrinsic", "(", ")", ")", "{", "switch", "(", "CalledF", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_sampler", ":", "Changed", "|=", "replaceIsTypePSampler", "(", "Instr", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_surface", ":", "Changed", "|=", "replaceIsTypePSurface", "(", "Instr", ")", ";", "break", ";", "case", "Intrinsic", "::", "nvvm_istypep_texture", ":", "Changed", "|=", "replaceIsTypePTexture", "(", "Instr", ")", ";", "break", ";", "}", "}", "}", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "InstrToDelete", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "InstrToDelete", "[", "i", "]", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "Intrinsic::nvvm_istypep_sampler", "Intrinsic::nvvm_istypep_surface", "Intrinsic::nvvm_istypep_texture", "0" ]

[]

[ "<s>", "void", "rs6000_print_patchable_function_entry", "(", "FILE", "*", "file", ",", "unsigned", "HOST_WIDE_INT", "patch_area_size", ",", "bool", "record_p", ")", "{", "bool", "global_entry_needed_p", "=", "rs6000_global_entry_point_prologue_needed_p", "(", ")", ";", "if", "(", "!", "global_entry_needed_p", "||", "cfun", "->", "machine", "->", "global_entry_emitted", ")", "default_print_patchable_function_entry", "(", "file", ",", "patch_area_size", ",", "record_p", ")", ";", "}", "</s>" ]

[ "Write", "PATCH_AREA_SIZE", "NOPs", "into", "the", "asm", "outfile", "FILE", "around", "a", "function", "entry", ".", "If", "RECORD_P", "is", "true", "and", "the", "target", "supports", "named", "sections", ",", "the", "location", "of", "the", "NOPs", "will", "be", "recorded", "in", "a", "special", "object", "section", "called", "``", "__patchable_function_entries", "''", ".", "This", "routine", "may", "be", "called", "twice", "per", "function", "to", "put", "NOPs", "before", "and", "after", "the", "function", "entry", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableAdvSIMDScalar", ")", "{", "addPass", "(", "createAArch64AdvSIMDScalar", "(", ")", ")", ";", "addPass", "(", "&", "PeepholeOptimizerID", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_expand_unary_operator", "(", "enum", "rtx_code", "code", ",", "enum", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "int", "matching_memory", ";", "rtx", "src", ",", "dst", ",", "op", ",", "clob", ";", "dst", "=", "operands", "[", "0", "]", ";", "src", "=", "operands", "[", "1", "]", ";", "matching_memory", "=", "0", ";", "if", "(", "MEM_P", "(", "dst", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "dst", ",", "src", ")", ")", "matching_memory", "=", "1", ";", "else", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "}", "if", "(", "MEM_P", "(", "src", ")", "&&", "!", "matching_memory", ")", "src", "=", "force_reg", "(", "mode", ",", "src", ")", ";", "op", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ")", ";", "if", "(", "reload_in_progress", "||", "code", "==", "NOT", ")", "{", "gcc_assert", "(", "code", "==", "NOT", ")", ";", "emit_insn", "(", "op", ")", ";", "}", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "}", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "expand", "a", "unary", "operator", ".", "Make", "the", "expansion", "closer", "to", "the", "actual", "machine", ",", "then", "just", "general_operand", ",", "which", "will", "allow", "2", "separate", "memory", "references", "(", "one", "output", ",", "one", "input", ")", "in", "a", "single", "insn", "." ]

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

[]

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

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

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "X86", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "hasGPR", "=", "false", ";", "unsigned", "FirstReg", "=", "0", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "MF", ".", "protectCSRs", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "if", "(", "!", "hasGPR", ")", "{", "FirstReg", "=", "Reg", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "hasGPR", "=", "true", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "ADD64rr", ")", ",", "FirstReg", ")", ".", "addReg", "(", "FirstReg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "if", "(", "MF", ".", "protectCSRs", "(", ")", "&&", "hasGPR", ")", "{", "assert", "(", "FirstReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "FirstReg", ",", "RegState", "::", "Kill", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "--", "MI", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "MI", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "0", "X86::PUSH64r", "X86::PUSH32r", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "X86::ADD64rr", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "static", "bool", "ix86_expand_sse_fp_minmax", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "if_true", ",", "rtx", "if_false", ")", "{", "machine_mode", "mode", ";", "bool", "is_min", ";", "rtx", "tmp", ";", "if", "(", "code", "==", "LT", ")", ";", "else", "if", "(", "code", "==", "UNGE", ")", "std", "::", "swap", "(", "if_true", ",", "if_false", ")", ";", "else", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "cmp_op0", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op1", ",", "if_false", ")", ")", "is_min", "=", "true", ";", "else", "if", "(", "rtx_equal_p", "(", "cmp_op1", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op0", ",", "if_false", ")", ")", "is_min", "=", "false", ";", "else", "return", "false", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "!", "flag_unsafe_math_optimizations", ")", "{", "int", "u", "=", "is_min", "?", "UNSPEC_IEEE_MIN", ":", "UNSPEC_IEEE_MAX", ";", "rtvec", "v", ";", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "v", "=", "gen_rtvec", "(", "2", ",", "if_true", ",", "if_false", ")", ";", "tmp", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "v", ",", "u", ")", ";", "}", "else", "{", "code", "=", "is_min", "?", "SMIN", ":", "SMAX", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "if_true", ",", "if_false", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "tmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Detect", "conditional", "moves", "that", "exactly", "match", "min/max", "operational", "semantics", ".", "Note", "that", "this", "is", "IEEE", "safe", ",", "as", "long", "as", "we", "do", "n't", "interchange", "the", "operands", ".", "Returns", "FALSE", "if", "this", "conditional", "move", "does", "n't", "match", "a", "MIN/MAX", ",", "and", "TRUE", "if", "the", "operation", "is", "successful", "and", "instructions", "are", "emitted", "." ]

[ "i386", "2" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "size", "(", ")", "==", "0", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon", "0" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreSched2", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createR600EmitClauseMarkers", "(", "*", "TM", ")", ")", ";", "addPass", "(", "&", "IfConverterID", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "NORTHERN_ISLANDS", ")", "addPass", "(", "createR600ClauseMergePass", "(", "*", "TM", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "rl78_expand_epilogue", "(", "void", ")", "{", "int", "i", ",", "fs", ";", "rtx", "sp", "=", "gen_rtx_REG", "(", "HImode", ",", "STACK_POINTER_REGNUM", ")", ";", "rtx", "ax", "=", "gen_rtx_REG", "(", "HImode", ",", "AX_REG", ")", ";", "int", "rb", "=", "0", ";", "if", "(", "rl78_is_naked_func", "(", ")", ")", "return", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_move_insn", "(", "ax", ",", "gen_rtx_REG", "(", "HImode", ",", "FRAME_POINTER_REGNUM", ")", ")", ";", "emit_move_insn", "(", "sp", ",", "ax", ")", ";", "}", "else", "{", "fs", "=", "cfun", "->", "machine", "->", "framesize_locals", "+", "cfun", "->", "machine", "->", "framesize_outgoing", ";", "if", "(", "fs", ">", "254", "*", "3", ")", "{", "emit_move_insn", "(", "ax", ",", "sp", ")", ";", "emit_insn", "(", "gen_addhi3", "(", "ax", ",", "ax", ",", "GEN_INT", "(", "fs", ")", ")", ")", ";", "emit_move_insn", "(", "sp", ",", "ax", ")", ";", "}", "else", "{", "while", "(", "fs", ">", "0", ")", "{", "int", "fs_byte", "=", "(", "fs", ">", "254", ")", "?", "254", ":", "fs", ";", "emit_insn", "(", "gen_addhi3", "(", "sp", ",", "sp", ",", "GEN_INT", "(", "fs_byte", ")", ")", ")", ";", "fs", "-=", "fs_byte", ";", "}", "}", "}", "if", "(", "is_interrupt_func", "(", "cfun", "->", "decl", ")", "&&", "cfun", "->", "machine", "->", "uses_es", ")", "{", "emit_insn", "(", "gen_pop", "(", "gen_rtx_REG", "(", "HImode", ",", "AX_REG", ")", ")", ")", ";", "emit_insn", "(", "gen_movqi_to_es", "(", "gen_rtx_REG", "(", "QImode", ",", "A_REG", ")", ")", ")", ";", "}", "for", "(", "i", "=", "15", ";", "i", ">=", "0", ";", "i", "--", ")", "if", "(", "cfun", "->", "machine", "->", "need_to_push", "[", "i", "]", ")", "{", "rtx", "dest", "=", "gen_rtx_REG", "(", "HImode", ",", "i", "*", "2", ")", ";", "if", "(", "TARGET_G10", ")", "{", "if", "(", "i", "<", "8", ")", "emit_insn", "(", "gen_pop", "(", "dest", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_pop", "(", "ax", ")", ")", ";", "emit_move_insn", "(", "dest", ",", "ax", ")", ";", "emit_insn", "(", "gen_use", "(", "dest", ")", ")", ";", "}", "}", "else", "{", "int", "need_bank", "=", "i", "/", "4", ";", "if", "(", "need_bank", "!=", "rb", ")", "{", "emit_insn", "(", "gen_sel_rb", "(", "GEN_INT", "(", "need_bank", ")", ")", ")", ";", "rb", "=", "need_bank", ";", "}", "emit_insn", "(", "gen_pop", "(", "dest", ")", ")", ";", "}", "}", "if", "(", "rb", "!=", "0", ")", "emit_insn", "(", "gen_sel_rb", "(", "GEN_INT", "(", "0", ")", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "trampolines_used", ")", "emit_insn", "(", "gen_trampoline_uninit", "(", ")", ")", ";", "if", "(", "is_brk_interrupt_func", "(", "cfun", "->", "decl", ")", ")", "emit_jump_insn", "(", "gen_brk_interrupt_return", "(", ")", ")", ";", "else", "if", "(", "is_interrupt_func", "(", "cfun", "->", "decl", ")", ")", "emit_jump_insn", "(", "gen_interrupt_return", "(", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_rl78_return", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "function", "epilogue", "(", "from", "the", "epilogue", "pattern", ")", "." ]

[ "rl78", "0", "254", "3", "0", "254", "254", "15", "0", "2", "8", "4", "0", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_advsimd_ldp_stp_p", "(", "enum", "vect_cost_for_stmt", "kind", ",", "stmt_vec_info", "stmt_info", ")", "{", "switch", "(", "kind", ")", "{", "case", "vector_load", ":", "case", "vector_store", ":", "case", "unaligned_load", ":", "case", "unaligned_store", ":", "break", ";", "default", ":", "return", "false", ";", "}", "if", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_NO_LDP_STP_QREGS", ")", "return", "false", ";", "return", "is_gimple_assign", "(", "stmt_info", "->", "stmt", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "creating", "multiple", "copies", "of", "STMT_INFO", "for", "Advanced", "SIMD", "vectors", "would", "produce", "a", "series", "of", "LDP", "or", "STP", "operations", ".", "KIND", "is", "the", "kind", "of", "statement", "that", "STMT_INFO", "represents", "." ]

[ "aarch64" ]

[]

[ "<s>", "virtual", "void", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "loadRegFromStack", "(", "MBB", ",", "MBBI", ",", "DestReg", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

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

[ "Mips", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "hasAndNotCompare", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "return", "(", "Subtarget", ".", "hasStdExtZbb", "(", ")", "||", "Subtarget", ".", "hasStdExtZbp", "(", ")", "||", "Subtarget", ".", "hasStdExtZbkb", "(", ")", ")", "&&", "!", "isa", "<", "ConstantSDNode", ">", "(", "Y", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "should", "transform", ":", "(", "X", "&", "Y", ")", "==", "Y", "�", "?", "(", "~X", "&", "Y", ")", "==", "0", "(", "X", "&", "Y", ")", "!", "=", "Y", "�", "?", "(", "~X", "&", "Y", ")", "!", "=", "0", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "mips16e_save_restore_pattern_p", "(", "rtx", "pattern", ",", "HOST_WIDE_INT", "adjust", ",", "struct", "mips16e_save_restore_info", "*", "info", ")", "{", "unsigned", "int", "i", ",", "nargs", ",", "mask", ",", "extra", ";", "HOST_WIDE_INT", "top_offset", ",", "save_offset", ",", "offset", ";", "rtx", "set", ",", "reg", ",", "mem", ",", "base", ";", "int", "n", ";", "if", "(", "!", "GENERATE_MIPS16E_SAVE_RESTORE", ")", "return", "false", ";", "top_offset", "=", "adjust", ">", "0", "?", "adjust", ":", "0", ";", "save_offset", "=", "top_offset", "-", "UNITS_PER_WORD", ";", "mask", "=", "0", ";", "nargs", "=", "0", ";", "i", "=", "0", ";", "for", "(", "n", "=", "1", ";", "n", "<", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "n", "++", ")", "{", "set", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "n", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "return", "false", ";", "mem", "=", "adjust", ">", "0", "?", "SET_SRC", "(", "set", ")", ":", "SET_DEST", "(", "set", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "return", "false", ";", "mips_split_plus", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "base", "!=", "stack_pointer_rtx", ")", "return", "false", ";", "reg", "=", "adjust", ">", "0", "?", "SET_DEST", "(", "set", ")", ":", "SET_SRC", "(", "set", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "false", ";", "if", "(", "offset", "==", "top_offset", "+", "nargs", "*", "UNITS_PER_WORD", "&&", "REGNO", "(", "reg", ")", "==", "GP_ARG_FIRST", "+", "nargs", ")", "nargs", "++", ";", "else", "if", "(", "offset", "==", "save_offset", ")", "{", "while", "(", "mips16e_save_restore_regs", "[", "i", "++", "]", "!=", "REGNO", "(", "reg", ")", ")", "if", "(", "i", "==", "ARRAY_SIZE", "(", "mips16e_save_restore_regs", ")", ")", "return", "false", ";", "mask", "|=", "1", "<<", "REGNO", "(", "reg", ")", ";", "save_offset", "-=", "UNITS_PER_WORD", ";", "}", "else", "return", "false", ";", "}", "extra", "=", "0", ";", "mips16e_mask_registers", "(", "&", "mask", ",", "mips16e_s2_s8_regs", ",", "ARRAY_SIZE", "(", "mips16e_s2_s8_regs", ")", ",", "&", "extra", ")", ";", "mips16e_mask_registers", "(", "&", "mask", ",", "mips16e_a0_a3_regs", ",", "ARRAY_SIZE", "(", "mips16e_a0_a3_regs", ")", ",", "&", "extra", ")", ";", "if", "(", "extra", "!=", "0", ")", "return", "false", ";", "if", "(", "nargs", ">", "0", "&&", "BITSET_P", "(", "mask", ",", "GP_ARG_FIRST", "+", "nargs", "-", "1", ")", ")", "return", "false", ";", "if", "(", "info", ")", "{", "info", "->", "nargs", "=", "nargs", ";", "info", "->", "mask", "=", "mask", ";", "info", "->", "size", "=", "(", "adjust", ">", "0", "?", "adjust", ":", "-", "adjust", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "PATTERN", "is", "a", "PARALLEL", "whose", "first", "element", "adds", "ADJUST", "to", "the", "stack", "pointer", ".", "Return", "true", "if", "PATTERN", "matches", "the", "kind", "of", "instruction", "generated", "by", "mips16e_build_save_restore", ".", "If", "INFO", "is", "nonnull", ",", "initialize", "it", "when", "returning", "true", "." ]

[ "mips", "0", "0", "0", "0", "0", "1", "0", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0" ]

[]