Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "combineSIGN_EXTEND", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "MERGE_HIGH", ":", "case", "SystemZISD", "::", "MERGE_LOW", ":", "return", "combineMERGE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "combineSTORE", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "combineEXTRACT_VECTOR_ELT", "(", "N", ",", "DCI", ")", ";", "case", "SystemZISD", "::", "JOIN_DWORDS", ":", "return", "combineJOIN_DWORDS", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "combineFP_ROUND", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "BSWAP", ":", "return", "combineBSWAP", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ROTL", ":", "return", "combineSHIFTROT", "(", "N", ",", "DCI", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "SystemZ", "SystemZ", "ISD::SIGN_EXTEND", "SystemZISD::MERGE_HIGH", "SystemZISD::MERGE_LOW", "ISD::STORE", "ISD::EXTRACT_VECTOR_ELT", "SystemZISD::JOIN_DWORDS", "ISD::FP_ROUND", "ISD::BSWAP", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ROTL" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "*", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "uint16_t", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "int", "Src2Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opcode", ",", "AMDGPU", "::", "OpName", "::", "src2", ")", ";", "if", "(", "isVOP1", "(", "Opcode", ")", "||", "isVOP2", "(", "Opcode", ")", "||", "isVOP3", "(", "Opcode", ")", "||", "isVOPC", "(", "Opcode", ")", ")", "{", "unsigned", "ConstantBusCount", "=", "0", ";", "unsigned", "SGPRUsed", "=", "AMDGPU", "::", "NoRegister", ";", "for", "(", "int", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isUse", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "EXEC", ")", "++", "ConstantBusCount", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "(", "!", "MO", ".", "isImplicit", "(", ")", "&&", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SGPR_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", ")", ")", "{", "if", "(", "SGPRUsed", "!=", "MO", ".", "getReg", "(", ")", ")", "{", "++", "ConstantBusCount", ";", "SGPRUsed", "=", "MO", ".", "getReg", "(", ")", ";", "}", "}", "}", "if", "(", "isLiteralConstant", "(", "MO", ")", ")", "++", "ConstantBusCount", ";", "}", "if", "(", "ConstantBusCount", ">", "1", ")", "{", "ErrInfo", "=", "\"VOP* instruction uses the constant bus more than once\"", ";", "return", "false", ";", "}", "}", "if", "(", "Src1Idx", "!=", "-", "1", "&&", "(", "isVOP2", "(", "Opcode", ")", "||", "isVOPC", "(", "Opcode", ")", ")", ")", "{", "const", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "{", "ErrInfo", "=", "\"VOP[2C] src1 cannot be an immediate.\"", ";", "return", "false", ";", "}", "}", "if", "(", "isVOP3", "(", "Opcode", ")", ")", "{", "if", "(", "Src0Idx", "!=", "-", "1", "&&", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "Src0Idx", ")", ")", ")", "{", "ErrInfo", "=", "\"VOP3 src0 cannot be a literal constant.\"", ";", "return", "false", ";", "}", "if", "(", "Src1Idx", "!=", "-", "1", "&&", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "Src1Idx", ")", ")", ")", "{", "ErrInfo", "=", "\"VOP3 src1 cannot be a literal constant.\"", ";", "return", "false", ";", "}", "if", "(", "Src2Idx", "!=", "-", "1", "&&", "isLiteralConstant", "(", "MI", "->", "getOperand", "(", "Src2Idx", ")", ")", ")", "{", "ErrInfo", "=", "\"VOP3 src2 cannot be a literal constant.\"", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "R600", "SI", "0", "0", "1", "\"VOP* instruction uses the constant bus more than once\"", "1", "\"VOP[2C] src1 cannot be an immediate.\"", "1", "\"VOP3 src0 cannot be a literal constant.\"", "1", "\"VOP3 src1 cannot be a literal constant.\"", "1", "\"VOP3 src2 cannot be a literal constant.\"" ]

[]

[ "<s>", "static", "rtx", "s390_emit_compare_and_swap", "(", "enum", "rtx_code", "code", ",", "rtx", "old", ",", "rtx", "mem", ",", "rtx", "cmp", ",", "rtx", "new_rtx", ",", "machine_mode", "ccmode", ")", "{", "rtx", "cc", ";", "cc", "=", "gen_rtx_REG", "(", "ccmode", ",", "CC_REGNUM", ")", ";", "switch", "(", "GET_MODE", "(", "mem", ")", ")", "{", "case", "SImode", ":", "emit_insn", "(", "gen_atomic_compare_and_swapsi_internal", "(", "old", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "cc", ")", ")", ";", "break", ";", "case", "DImode", ":", "emit_insn", "(", "gen_atomic_compare_and_swapdi_internal", "(", "old", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "cc", ")", ")", ";", "break", ";", "case", "TImode", ":", "emit_insn", "(", "gen_atomic_compare_and_swapti_internal", "(", "old", ",", "mem", ",", "cmp", ",", "new_rtx", ",", "cc", ")", ")", ";", "break", ";", "case", "QImode", ":", "case", "HImode", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "s390_emit_compare", "(", "code", ",", "cc", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "a", "SImode", "compare", "and", "swap", "instruction", "setting", "MEM", "to", "NEW_RTX", "if", "OLD", "matches", "CMP", ".", "Return", "the", "correct", "condition", "RTL", "to", "be", "placed", "in", "the", "IF_THEN_ELSE", "of", "the", "conditional", "branch", "testing", "the", "result", "." ]

[ "s390" ]

[]

[ "<s>", "static", "void", "aarch64_emit_store_exclusive", "(", "machine_mode", "mode", ",", "rtx", "bval", ",", "rtx", "rval", ",", "rtx", "mem", ",", "rtx", "model_rtx", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "gen", "=", "gen_aarch64_store_exclusiveqi", ";", "break", ";", "case", "HImode", ":", "gen", "=", "gen_aarch64_store_exclusivehi", ";", "break", ";", "case", "SImode", ":", "gen", "=", "gen_aarch64_store_exclusivesi", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_aarch64_store_exclusivedi", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "bval", ",", "rval", ",", "mem", ",", "model_rtx", ")", ")", ";", "}", "</s>" ]

[ "Emit", "store", "exclusive", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "getEUsPerCU", "(", "const", "MCSubtargetInfo", "*", "STI", ")", "{", "return", "4", ";", "}", "</s>" ]

[ "Number", "of", "SIMDs/EUs", "(", "execution", "units", ")", "per", "``", "CU", "''", "(", "``", "compute", "unit", "''", ")", ",", "where", "the", "``", "CU", "''", "is", "the", "unit", "onto", "which", "workgroups", "are", "mapped", "." ]

[ "AMDGPU", "4" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getGatherScatterOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "SrcVTy", ",", "Value", "*", "Ptr", ",", "bool", "VariableMask", ",", "unsigned", "Alignment", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "const", "Instruction", "*", "I", "=", "nullptr", ")", "{", "assert", "(", "SrcVTy", "->", "isVectorTy", "(", ")", "&&", "\"Unexpected data type for Gather/Scatter\"", ")", ";", "unsigned", "VF", "=", "cast", "<", "VectorType", ">", "(", "SrcVTy", ")", "->", "getNumElements", "(", ")", ";", "PointerType", "*", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", ";", "if", "(", "!", "PtrTy", "&&", "Ptr", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "PtrTy", "=", "dyn_cast", "<", "PointerType", ">", "(", "cast", "<", "VectorType", ">", "(", "Ptr", "->", "getType", "(", ")", ")", "->", "getElementType", "(", ")", ")", ";", "assert", "(", "PtrTy", "&&", "\"Unexpected type for Ptr argument\"", ")", ";", "unsigned", "AddressSpace", "=", "PtrTy", "->", "getAddressSpace", "(", ")", ";", "bool", "Scalarize", "=", "false", ";", "if", "(", "(", "Opcode", "==", "Instruction", "::", "Load", "&&", "!", "isLegalMaskedGather", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", "||", "(", "Opcode", "==", "Instruction", "::", "Store", "&&", "!", "isLegalMaskedScatter", "(", "SrcVTy", ",", "MaybeAlign", "(", "Alignment", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "ST", "->", "hasAVX512", "(", ")", "&&", "(", "VF", "==", "2", "||", "(", "VF", "==", "4", "&&", "!", "ST", "->", "hasVLX", "(", ")", ")", ")", ")", "Scalarize", "=", "true", ";", "if", "(", "Scalarize", ")", "return", "getGSScalarCost", "(", "Opcode", ",", "SrcVTy", ",", "VariableMask", ",", "Alignment", ",", "AddressSpace", ")", ";", "return", "getGSVectorCost", "(", "Opcode", ",", "SrcVTy", ",", "Ptr", ",", "Alignment", ",", "AddressSpace", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "Gather", "/", "Scatter", "operation", "." ]

[ "X86", "X86", "\"Unexpected data type for Gather/Scatter\"", "\"Unexpected type for Ptr argument\"", "2", "4" ]

[]

[ "<s>", "static", "bool", "arm_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", "==", "CODE_FOR_tlscall", ")", "return", "true", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC_BASE", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC_UNIFIED", ")", ")", "return", "true", ";", "}", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "ZERO_EXTEND", ")", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "UNSPEC_VOLATILE", "&&", "(", "XINT", "(", "src", ",", "1", ")", "==", "VUNSPEC_LL", "||", "XINT", "(", "src", ",", "1", ")", "==", "VUNSPEC_LAX", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Must", "not", "copy", "any", "rtx", "that", "uses", "a", "pc-relative", "address", "." ]

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

[]

[ "<s>", "MCELFStreamer", "&", "MSP430TargetELFStreamer", "::", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "void", "ix86_register_pragmas", "(", "void", ")", "{", "targetm", ".", "target_option", ".", "pragma_parse", "=", "ix86_pragma_target_parse", ";", "REGISTER_SUBTARGET_PRAGMAS", "(", ")", ";", "}", "</s>" ]

[ "Register", "target", "pragmas", ".", "We", "need", "to", "add", "the", "hook", "for", "parsing", "#", "pragma", "GCC", "option", "here", "rather", "than", "in", "i386.cc", "since", "it", "will", "pull", "in", "various", "preprocessor", "functions", ",", "and", "those", "are", "not", "present", "in", "languages", "like", "fortran", "without", "a", "preprocessor", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "segv_crash_handler", "(", "int", "sig", "ATTRIBUTE_UNUSED", ")", "{", "internal_error", "(", "\"segmentation fault (code)\"", ")", ";", "}", "</s>" ]

[ "On", "Darwin/powerpc", ",", "hitting", "the", "stack", "limit", "turns", "into", "a", "SIGSEGV", ".", "This", "code", "detects", "the", "difference", "between", "hitting", "the", "stack", "limit", "and", "a", "true", "wild", "pointer", "dereference", "by", "looking", "at", "the", "instruction", "that", "faulted", ";", "only", "a", "few", "kinds", "of", "instruction", "are", "used", "to", "access", "below", "the", "previous", "bottom", "of", "the", "stack", "." ]

[ "rs6000", "\"segmentation fault (code)\"" ]

[]

[ "<s>", "static", "void", "function_arg_record_value_3", "(", "HOST_WIDE_INT", "bitpos", ",", "struct", "function_arg_record_value_parms", "*", "parms", ")", "{", "machine_mode", "mode", ";", "unsigned", "int", "regno", ";", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "this_slotno", ",", "intslots", ",", "intoffset", ";", "rtx", "reg", ";", "if", "(", "parms", "->", "intoffset", "==", "-", "1", ")", "return", ";", "intoffset", "=", "parms", "->", "intoffset", ";", "parms", "->", "intoffset", "=", "-", "1", ";", "startbit", "=", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "bitpos", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intslots", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_slotno", "=", "parms", "->", "slotno", "+", "intoffset", "/", "BITS_PER_WORD", ";", "intslots", "=", "MIN", "(", "intslots", ",", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", ";", "if", "(", "intslots", "<=", "0", ")", "return", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "mode", "=", "smallest_mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ",", "MODE_INT", ")", ";", "else", "mode", "=", "word_mode", ";", "intoffset", "/=", "BITS_PER_UNIT", ";", "do", "{", "regno", "=", "parms", "->", "regbase", "+", "this_slotno", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "parms", "->", "ret", ",", "0", ",", "parms", "->", "stack", "+", "parms", "->", "nregs", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "this_slotno", "+=", "1", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "+", "1", ";", "mode", "=", "word_mode", ";", "parms", "->", "nregs", "+=", "1", ";", "intslots", "-=", "1", ";", "}", "while", "(", "intslots", ">", "0", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Assign", "the", "bits", "of", "the", "structure", "between", "parms-", ">", "intoffset", "and", "bitpos", "to", "integer", "registers", "." ]

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

[]

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

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

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

[]

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

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

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

[]

[ "<s>", "static", "FunctionType", "*", "getType", "(", "LLVMContext", "&", "Context", ",", "unsigned", "id", ")", "{", "Type", "*", "ResultTy", "=", "NULL", ";", "SmallVector", "<", "Type", "*", ",", "8", ">", "ArgTys", ";", "bool", "IsVarArg", "=", "false", ";", "return", "FunctionType", "::", "get", "(", "ResultTy", ",", "ArgTys", ",", "IsVarArg", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "8" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Expand special instructions pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Expand special instructions pass\"" ]

[]

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

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

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

[]

[ "<s>", "void", "s390_function_profiler", "(", "FILE", "*", "file", ",", "int", "labelno", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "op", "[", "4", "]", ";", "fprintf", "(", "file", ",", "\"# function profiler \\n\"", ")", ";", "op", "[", "0", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_REGNUM", ")", ";", "op", "[", "1", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "op", "[", "1", "]", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "op", "[", "1", "]", ",", "UNITS_PER_LONG", ")", ")", ";", "op", "[", "3", "]", "=", "GEN_INT", "(", "UNITS_PER_LONG", ")", ";", "op", "[", "2", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "flag_fentry", "?", "\"__fentry__\"", ":", "\"_mcount\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "op", "[", "2", "]", ")", "|=", "SYMBOL_FLAG_FUNCTION", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_64BIT", ")", "{", "op", "[", "2", "]", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "op", "[", "2", "]", ")", ",", "UNSPEC_PLT31", ")", ";", "op", "[", "2", "]", "=", "gen_rtx_CONST", "(", "Pmode", ",", "op", "[", "2", "]", ")", ";", "}", "if", "(", "flag_record_mcount", ")", "fprintf", "(", "file", ",", "\"1:\\n\"", ")", ";", "if", "(", "flag_fentry", ")", "{", "if", "(", "flag_nop_mcount", ")", "output_asm_nops", "(", "\"-mnop-mcount\"", ",", "3", ")", ";", "else", "if", "(", "cfun", "->", "static_chain_decl", ")", "warning", "(", "OPT_Wcannot_profile", ",", "\"nested functions cannot be profiled \"", "\"with %<-mfentry%> on s390\"", ")", ";", "else", "output_asm_insn", "(", "\"brasl\\t0,%2%K2\"", ",", "op", ")", ";", "}", "else", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "flag_nop_mcount", ")", "output_asm_nops", "(", "\"-mnop-mcount\"", ",", "3", "+", "3", "+", "3", ")", ";", "else", "{", "output_asm_insn", "(", "\"stg\\t%0,%1\"", ",", "op", ")", ";", "if", "(", "flag_dwarf2_cfi_asm", ")", "output_asm_insn", "(", "\".cfi_rel_offset\\t%0,%3\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"brasl\\t%0,%2%K2\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"lg\\t%0,%1\"", ",", "op", ")", ";", "if", "(", "flag_dwarf2_cfi_asm", ")", "output_asm_insn", "(", "\".cfi_restore\\t%0\"", ",", "op", ")", ";", "}", "}", "else", "{", "if", "(", "flag_nop_mcount", ")", "output_asm_nops", "(", "\"-mnop-mcount\"", ",", "2", "+", "3", "+", "2", ")", ";", "else", "{", "output_asm_insn", "(", "\"st\\t%0,%1\"", ",", "op", ")", ";", "if", "(", "flag_dwarf2_cfi_asm", ")", "output_asm_insn", "(", "\".cfi_rel_offset\\t%0,%3\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"brasl\\t%0,%2%K2\"", ",", "op", ")", ";", "output_asm_insn", "(", "\"l\\t%0,%1\"", ",", "op", ")", ";", "if", "(", "flag_dwarf2_cfi_asm", ")", "output_asm_insn", "(", "\".cfi_restore\\t%0\"", ",", "op", ")", ";", "}", "}", "if", "(", "flag_record_mcount", ")", "{", "fprintf", "(", "file", ",", "\"\\t.section __mcount_loc, \\\"a\\\",@progbits\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.%s 1b\\n\"", ",", "TARGET_64BIT", "?", "\"quad\"", ":", "\"long\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t.previous\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "FILE", "to", "call", "a", "profiler", "hook", "." ]

[ "s390", "4", "\"# function profiler \\n\"", "0", "1", "1", "1", "3", "2", "\"__fentry__\"", "\"_mcount\"", "2", "2", "1", "2", "2", "2", "\"1:\\n\"", "\"-mnop-mcount\"", "3", "\"nested functions cannot be profiled \"", "\"with %<-mfentry%> on s390\"", "\"brasl\\t0,%2%K2\"", "\"-mnop-mcount\"", "3", "3", "3", "\"stg\\t%0,%1\"", "\".cfi_rel_offset\\t%0,%3\"", "\"brasl\\t%0,%2%K2\"", "\"lg\\t%0,%1\"", "\".cfi_restore\\t%0\"", "\"-mnop-mcount\"", "2", "3", "2", "\"st\\t%0,%1\"", "\".cfi_rel_offset\\t%0,%3\"", "\"brasl\\t%0,%2%K2\"", "\"l\\t%0,%1\"", "\".cfi_restore\\t%0\"", "\"\\t.section __mcount_loc, \\\"a\\\",@progbits\\n\"", "\"\\t.%s 1b\\n\"", "\"quad\"", "\"long\"", "\"\\t.previous\\n\"" ]

[]

[ "<s>", "bool", "LinearizedRegion", "::", "isLiveOut", "(", "unsigned", "Reg", ")", "{", "return", "LiveOuts", ".", "count", "(", "Reg", ")", "==", "1", ";", "}", "</s>" ]

[ "isLiveOut", "-", "Determine", "if", "Reg", "is", "live", "out", "from", "MBB", ",", "when", "not", "considering", "PHI", "nodes", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "int", "legitimate_pic_operand_p", "(", "rtx", "op", ")", "{", "if", "(", "!", "SYMBOLIC_CONST", "(", "op", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "OP", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

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

[]

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

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

[ "AAP", "AAP" ]

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction not supported on this GPU\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0ULL", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "{", "if", "(", "isForcedVOP3", "(", ")", ")", "{", "AMDGPUOperand", "&", "LastOp", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "Operands", ".", "size", "(", ")", "-", "1", "]", ")", ";", "if", "(", "LastOp", ".", "isRegKind", "(", ")", "||", "(", "LastOp", ".", "isImm", "(", ")", "&&", "LastOp", ".", "getImmTy", "(", ")", "!=", "AMDGPUOperand", "::", "ImmTyNone", ")", ")", "{", "SMLoc", "S", "=", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "0", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyClamp", ")", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "0", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyOMod", ")", ")", ";", "bool", "Res", "=", "MatchAndEmitInstruction", "(", "IDLoc", ",", "Opcode", ",", "Operands", ",", "Out", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "if", "(", "!", "Res", ")", "return", "Res", ";", "}", "}", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "}", "ErrorLoc", "=", "(", "(", "AMDGPUOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "R600", "\"instruction not supported on this GPU\"", "\"unrecognized instruction mnemonic\"", "0ULL", "1", "0", "0", "\"too few operands for instruction\"", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "rtx", "riscv_subword", "(", "rtx", "op", ",", "bool", "high_p", ")", "{", "unsigned", "int", "byte", "=", "(", "high_p", "!=", "BYTES_BIG_ENDIAN", ")", "?", "UNITS_PER_WORD", ":", "0", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "TARGET_64BIT", "?", "TImode", ":", "DImode", ";", "if", "(", "MEM_P", "(", "op", ")", ")", "return", "adjust_address", "(", "op", ",", "word_mode", ",", "byte", ")", ";", "if", "(", "REG_P", "(", "op", ")", ")", "gcc_assert", "(", "!", "FP_REG_RTX_P", "(", "op", ")", ")", ";", "return", "simplify_gen_subreg", "(", "word_mode", ",", "op", ",", "mode", ",", "byte", ")", ";", "}", "</s>" ]

[ "Return", "one", "word", "of", "double-word", "value", "OP", ".", "HIGH_P", "is", "true", "to", "select", "the", "high", "part", "or", "false", "to", "select", "the", "low", "part", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "int", "xtensa_debugger_regno", "(", "int", "regno", ")", "{", "int", "first", "=", "-", "1", ";", "if", "(", "GP_REG_P", "(", "regno", ")", ")", "{", "regno", "-=", "GP_REG_FIRST", ";", "first", "=", "0", ";", "}", "else", "if", "(", "BR_REG_P", "(", "regno", ")", ")", "{", "regno", "-=", "BR_REG_FIRST", ";", "first", "=", "16", ";", "}", "else", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "{", "regno", "-=", "FP_REG_FIRST", ";", "first", "=", "48", ";", "}", "else", "if", "(", "ACC_REG_P", "(", "regno", ")", ")", "{", "first", "=", "0x200", ";", "regno", "=", "16", ";", "}", "if", "(", "first", "==", "-", "1", ")", "return", "0", ";", "return", "first", "+", "regno", ";", "}", "</s>" ]

[ "Return", "the", "debugger", "register", "number", "to", "use", "for", "'regno", "'", "." ]

[ "xtensa", "1", "0", "16", "48", "0x200", "16", "1", "0" ]

[]

[ "<s>", "static", "void", "aarch64_set_handled_components", "(", "sbitmap", "components", ")", "{", "for", "(", "unsigned", "regno", "=", "0", ";", "regno", "<=", "LAST_SAVED_REGNUM", ";", "regno", "++", ")", "if", "(", "bitmap_bit_p", "(", "components", ",", "regno", ")", ")", "cfun", "->", "machine", "->", "reg_is_wrapped_separately", "[", "regno", "]", "=", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "static", "inline", "bool", "mode_supports_dq_form", "(", "machine_mode", "mode", ")", "{", "return", "(", "(", "reg_addr", "[", "mode", "]", ".", "addr_mask", "[", "RELOAD_REG_ANY", "]", "&", "RELOAD_REG_QUAD_OFFSET", ")", "!=", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "have", "D-form", "addressing", "in", "VSX", "registers", ".", "This", "addressing", "is", "more", "limited", "than", "normal", "d-form", "addressing", "in", "that", "the", "offset", "must", "be", "aligned", "on", "a", "16-byte", "boundary", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "int", "shl_sext_kind", "(", "rtx", "left_rtx", ",", "rtx", "size_rtx", ",", "int", "*", "costp", ")", "{", "int", "left", ",", "size", ",", "insize", ",", "ext", ";", "int", "cost", "=", "0", ",", "best_cost", ";", "int", "kind", ";", "left", "=", "INTVAL", "(", "left_rtx", ")", ";", "size", "=", "INTVAL", "(", "size_rtx", ")", ";", "insize", "=", "size", "-", "left", ";", "gcc_assert", "(", "insize", ">", "0", ")", ";", "kind", "=", "0", ";", "best_cost", "=", "shift_insns", "[", "32", "-", "insize", "]", "+", "ashiftrt_insns", "[", "32", "-", "size", "]", ";", "if", "(", "size", "<=", "16", ")", "{", "cost", "=", "shift_insns", "[", "16", "-", "insize", "]", "+", "1", "+", "ashiftrt_insns", "[", "16", "-", "size", "]", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "5", ";", "best_cost", "=", "cost", ";", "}", "}", "for", "(", "ext", "=", "16", ";", "ext", ">=", "insize", ";", "ext", "-=", "8", ")", "{", "if", "(", "ext", "<=", "size", ")", "{", "cost", "=", "ext_shift_insns", "[", "ext", "-", "insize", "]", "+", "1", "+", "shift_insns", "[", "size", "-", "ext", "]", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "ext", "/", "(", "unsigned", ")", "8", ";", "best_cost", "=", "cost", ";", "}", "}", "if", "(", "EXT_SHIFT_SIGNED", "(", "size", "-", "ext", ")", ")", "cost", "=", "ext_shift_insns", "[", "ext", "-", "insize", "]", "+", "ext_shift_insns", "[", "size", "-", "ext", "]", "+", "1", ";", "else", "if", "(", "size", "<=", "16", ")", "cost", "=", "ext_shift_insns", "[", "ext", "-", "insize", "]", "+", "1", "+", "ext_shift_insns", "[", "size", ">", "ext", "?", "size", "-", "ext", ":", "ext", "-", "size", "]", "+", "1", ";", "else", "continue", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "ext", "/", "(", "unsigned", ")", "8", "+", "2", ";", "best_cost", "=", "cost", ";", "}", "}", "if", "(", "insize", "<", "8", ")", "{", "cost", "=", "3", "+", "shift_insns", "[", "left", "]", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "6", ";", "best_cost", "=", "cost", ";", "}", "if", "(", "left", "<", "31", ")", "{", "cost", "=", "3", "+", "ext_shift_insns", "[", "left", "+", "1", "]", "+", "1", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "7", ";", "best_cost", "=", "cost", ";", "}", "}", "}", "if", "(", "TARGET_SH3", ")", "{", "cost", "=", "shift_insns", "[", "32", "-", "insize", "]", "+", "1", "+", "SH_DYNAMIC_SHIFT_COST", ";", "if", "(", "cost", "<", "best_cost", ")", "{", "kind", "=", "0", ";", "best_cost", "=", "cost", ";", "}", "}", "if", "(", "costp", ")", "*", "costp", "=", "cost", ";", "return", "kind", ";", "}", "</s>" ]

[ "Try", "to", "find", "a", "good", "way", "to", "implement", "the", "combiner", "pattern", "[", "(", "set", "(", "match_operand", ":", "SI", "0", "``", "register_operand", "''", "``", "=r", "''", ")", "(", "sign_extract", ":", "SI", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "1", "``", "register_operand", "''", "``", "r", "''", ")", "(", "match_operand", ":", "SI", "2", "``", "const_int_operand", "''", "``", "n", "''", ")", "(", "match_operand", ":", "SI", "3", "``", "const_int_operand", "''", "``", "n", "''", ")", "(", "const_int", "0", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "T_REG", ")", ")", "]", "LEFT_RTX", "is", "operand", "2", "in", "the", "above", "pattern", ",", "and", "SIZE_RTX", "is", "operand", "3.", "return", "0", "for", "simple", "left", "/", "right", "shift", "combination", ".", "return", "1", "for", "left", "shift", "/", "8", "bit", "sign", "extend", "/", "left", "shift", ".", "return", "2", "for", "left", "shift", "/", "16", "bit", "sign", "extend", "/", "left", "shift", ".", "return", "3", "for", "left", "shift", "/", "8", "bit", "sign", "extend", "/", "shift", "/", "sign", "extend", ".", "return", "4", "for", "left", "shift", "/", "16", "bit", "sign", "extend", "/", "shift", "/", "sign", "extend", ".", "return", "5", "for", "left", "shift", "/", "16", "bit", "sign", "extend", "/", "right", "shift", "return", "6", "for", "<", "8", "bit", "sign", "extend", "/", "left", "shift", ".", "return", "7", "for", "<", "8", "bit", "sign", "extend", "/", "left", "shift", "/", "single", "right", "shift", ".", "If", "COSTP", "is", "nonzero", ",", "assign", "the", "calculated", "cost", "to", "*", "COSTP", "." ]

[ "sh", "0", "0", "0", "32", "32", "16", "16", "1", "16", "5", "16", "8", "1", "8", "1", "16", "1", "1", "8", "2", "8", "3", "6", "31", "3", "1", "1", "7", "32", "1", "0" ]

[]

[ "<s>", "void", "AnalyzeReturn", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "CCAssignFn", "Fn", ")", "{", "PreAnalyzeReturnForF128", "(", "Outs", ")", ";", "CCState", "::", "AnalyzeReturn", "(", "Outs", ",", "Fn", ")", ";", "OriginalArgWasF128", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AnalyzeReturn", "-", "Analyze", "the", "returned", "values", "of", "a", "return", ",", "incorporating", "info", "about", "the", "result", "values", "into", "this", "state", "." ]

[ "Mips", "ISD::OutputArg" ]

[]

[ "<s>", "bool", "Z80FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "UseShadow", "=", "shouldUseShadow", "(", "MF", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "UseShadow", ")", "shadowCalleeSavedRegisters", "(", "MBB", ",", "MI", ",", "DL", ",", "MachineInstr", "::", "FrameSetup", ",", "CSI", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "UseShadow", "&&", "!", "Z80", "::", "I24RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "Z80", "::", "I16RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "bool", "isLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "CanKill", "=", "!", "isLiveIn", ";", "if", "(", "CanKill", ")", "{", "for", "(", "MCRegAliasIterator", "AReg", "(", "Reg", ",", "TRI", ",", "false", ")", ";", "AReg", ".", "isValid", "(", ")", ";", "++", "AReg", ")", "{", "if", "(", "MRI", ".", "isLiveIn", "(", "*", "AReg", ")", ")", "{", "CanKill", "=", "false", ";", "break", ";", "}", "}", "}", "MachineInstrBuilder", "MIB", ";", "if", "(", "Reg", "==", "Z80", "::", "AF", ")", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "PUSH24AF", ":", "Z80", "::", "PUSH16AF", ")", ")", ";", "else", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Is24Bit", "?", "Z80", "::", "PUSH24r", ":", "Z80", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "CanKill", ")", ")", ";", "MIB", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "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", "(", ")", "." ]

[ "Z80", "Z80", "0", "1", "Z80::I24RegClass", "Z80::I16RegClass", "Z80::AF", "Z80::PUSH24AF", "Z80::PUSH16AF", "Z80::PUSH24r", "Z80::PUSH16r" ]

[]

[ "<s>", "static", "bool", "has_vtype_op", "(", "rtx_insn", "*", "rinsn", ")", "{", "return", "recog_memoized", "(", "rinsn", ")", ">=", "0", "&&", "get_attr_has_vtype_op", "(", "rinsn", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "an", "RVV", "instruction", "depends", "on", "VTYPE", "global", "status", "register", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNSAtoVMEMBug", "(", ")", "&&", "checkNSAtoVMEMHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "TII", ",", "*", "MI", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "checkMAIHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isDS", "(", "*", "MI", ")", ")", "&&", "checkMAILdStHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "NoopHazard", ";", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

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

[]

[ "<s>", "bool", "LC2200PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createLC2200ISelDag", "(", "getLC2200TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "LC2200", "LC2200", "LC2200", "LC2200" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "XCoreFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "XCoreSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "uint64_t", "Amount", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "errs", "(", ")", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "nullptr", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", ".", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", ".", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6", ":", "XCore", "::", "LDAWSP_lru6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6", "XCore::LDAWSP_lru6", "XCore::SP" ]

[]

[ "<s>", "bool", "Z80oldTargetLowering", "::", "shouldConvertConstantLoadToIntImm", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "it", "is", "beneficial", "to", "convert", "a", "load", "of", "a", "constant", "to", "just", "the", "constant", "itself", "." ]

[ "Z80old", "Z80old" ]

[]

[ "<s>", "StackOffset", "AArch64FrameLowering", "::", "getFrameIndexReferencePreferSP", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ",", "bool", "IgnoreSPUpdates", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "IgnoreSPUpdates", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset from the SP for \"", "<<", "FI", "<<", "\" is \"", "<<", "MFI", ".", "getObjectOffset", "(", "FI", ")", "<<", "\"\\n\"", ")", ";", "FrameReg", "=", "AArch64", "::", "SP", ";", "return", "StackOffset", "::", "getFixed", "(", "MFI", ".", "getObjectOffset", "(", "FI", ")", ")", ";", "}", "return", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "FrameReg", ")", ";", "}", "</s>" ]

[ "Same", "as", "getFrameIndexReference", ",", "except", "that", "the", "stack", "pointer", "(", "as", "opposed", "to", "the", "frame", "pointer", ")", "will", "be", "the", "preferred", "value", "for", "FrameReg", "." ]

[ "AArch64", "AArch64", "\"Offset from the SP for \"", "\" is \"", "\"\\n\"", "AArch64::SP" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "getMachineCombinerPatterns", "(", "MachineInstr", "&", "Root", ",", "SmallVectorImpl", "<", "MachineCombinerPattern", ">", "&", "Patterns", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "Aggressive", ")", "return", "false", ";", "return", "TargetInstrInfo", "::", "getMachineCombinerPatterns", "(", "Root", ",", "Patterns", ")", ";", "}", "</s>" ]

[ "Return", "true", "when", "there", "is", "potentially", "a", "faster", "code", "sequence", "for", "an", "instruction", "chain", "ending", "in", "Root", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "TCycles", ",", "unsigned", "TExtra", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "FCycles", ",", "unsigned", "FExtra", ",", "BranchProbability", "Probability", ")", "const", "{", "if", "(", "!", "TCycles", "||", "!", "FCycles", ")", "return", "false", ";", "const", "unsigned", "ScalingUpFactor", "=", "1024", ";", "unsigned", "TUnpredCost", "=", "Probability", ".", "scale", "(", "TCycles", "*", "ScalingUpFactor", ")", ";", "unsigned", "FUnpredCost", "=", "Probability", ".", "getCompl", "(", ")", ".", "scale", "(", "FCycles", "*", "ScalingUpFactor", ")", ";", "unsigned", "UnpredCost", "=", "TUnpredCost", "+", "FUnpredCost", ";", "UnpredCost", "+=", "1", "*", "ScalingUpFactor", ";", "UnpredCost", "+=", "Subtarget", ".", "getMispredictionPenalty", "(", ")", "*", "ScalingUpFactor", "/", "10", ";", "return", "(", "TCycles", "+", "FCycles", "+", "TExtra", "+", "FExtra", ")", "*", "ScalingUpFactor", "<=", "UnpredCost", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "ARM", "ARM", "1024", "1", "10" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "bool", "SpillVGPRToAGPR", "=", "ST", ".", "hasMAIInsts", "(", ")", "&&", "FuncInfo", "->", "hasSpilledVGPRs", "(", ")", "&&", "EnableSpillVGPRToAGPR", ";", "if", "(", "SpillVGPRToAGPR", ")", "{", "BitVector", "SpillFIs", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ",", "false", ")", ";", "bool", "SeenDbgInstr", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "::", "iterator", "Next", ";", "for", "(", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "SeenDbgInstr", "=", "true", ";", "if", "(", "TII", "->", "isVGPRSpill", "(", "MI", ")", ")", "{", "unsigned", "FIOp", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "Register", "VReg", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", "->", "getReg", "(", ")", ";", "if", "(", "FuncInfo", "->", "allocateVGPRSpillToAGPR", "(", "MF", ",", "FI", ",", "TRI", "->", "isAGPR", "(", "MRI", ",", "VReg", ")", ")", ")", "{", "RS", "->", "enterBasicBlock", "(", "MBB", ")", ";", "TRI", "->", "eliminateFrameIndex", "(", "MI", ",", "0", ",", "FIOp", ",", "RS", ")", ";", "SpillFIs", ".", "set", "(", "FI", ")", ";", "continue", ";", "}", "}", "}", "}", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MCPhysReg", "Reg", ":", "FuncInfo", "->", "getVGPRSpillAGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "for", "(", "MCPhysReg", "Reg", ":", "FuncInfo", "->", "getAGPRSpillVGPRs", "(", ")", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MBB", ".", "sortUniqueLiveIns", "(", ")", ";", "if", "(", "!", "SpillFIs", ".", "empty", "(", ")", "&&", "SeenDbgInstr", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugValue", "(", ")", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isFI", "(", ")", "&&", "SpillFIs", "[", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", "]", ")", "{", "MI", ".", "getOperand", "(", "0", ")", ".", "ChangeToRegister", "(", "Register", "(", ")", ",", "false", ")", ";", "}", "}", "}", "}", "}", "FuncInfo", "->", "removeDeadFrameIndices", "(", "MF", ")", ";", "assert", "(", "allSGPRSpillsAreDead", "(", "MF", ")", "&&", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", ")", ";", "if", "(", "!", "allStackObjectsAreDead", "(", "MF", ")", ")", "{", "assert", "(", "RS", "&&", "\"RegScavenger required if spilling\"", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FuncInfo", "->", "getScavengeFI", "(", "MFI", ",", "*", "TRI", ")", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "AMDGPU::OpName", "0", "0", "0", "0", "\"SGPR spill should have been removed in SILowerSGPRSpills\"", "\"RegScavenger required if spilling\"" ]

[]

[ "<s>", "static", "int", "stackSlotSize", "(", ")", "{", "return", "4", ";", "}", "</s>" ]

[ "Stack", "slot", "size", "(", "4", "bytes", ")" ]

[ "CJG", "4" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"A57 FP Anti-dependency breaker\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"A57 FP Anti-dependency breaker\"" ]

[]

[ "<s>", "LLT", "AArch64TargetLowering", "::", "getOptimalMemOpLLT", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "bool", "CanImplicitFloat", "=", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "bool", "CanUseNEON", "=", "Subtarget", "->", "hasNEON", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "CanUseFP", "=", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "IsSmallMemset", "=", "Op", ".", "isMemset", "(", ")", "&&", "Op", ".", "size", "(", ")", "<", "32", ";", "auto", "AlignmentIsAcceptable", "=", "[", "&", "]", "(", "EVT", "VT", ",", "Align", "AlignCheck", ")", "{", "if", "(", "Op", ".", "isAligned", "(", "AlignCheck", ")", ")", "return", "true", ";", "bool", "Fast", ";", "return", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "0", ",", "Align", "(", "1", ")", ",", "MachineMemOperand", "::", "MONone", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", ";", "if", "(", "CanUseNEON", "&&", "Op", ".", "isMemset", "(", ")", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "v2i64", ",", "Align", "(", "16", ")", ")", ")", "return", "LLT", "::", "fixed_vector", "(", "2", ",", "64", ")", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "Align", "(", "16", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "128", ")", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "Align", "(", "8", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "64", ")", ";", "if", "(", "Op", ".", "size", "(", ")", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "Align", "(", "4", ")", ")", ")", "return", "LLT", "::", "scalar", "(", "32", ")", ";", "return", "LLT", "(", ")", ";", "}", "</s>" ]

[ "LLT", "returning", "variant", "." ]

[ "AArch64", "AArch64", "32", "0", "1", "MVT::v2i64", "16", "2", "64", "MVT::f128", "16", "128", "8", "MVT::i64", "8", "64", "4", "MVT::i32", "4", "32" ]

[]

[ "<s>", "void", "paired_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "int", "n_var", "=", "0", ";", "rtx", "x", ",", "new_rtx", ",", "tmp", ",", "constant_op", ",", "op1", ",", "op2", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "(", "CONST_SCALAR_INT_P", "(", "x", ")", "||", "CONST_DOUBLE_P", "(", "x", ")", "||", "CONST_FIXED_P", "(", "x", ")", ")", ")", "++", "n_var", ";", "}", "if", "(", "n_var", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ";", "return", ";", "}", "if", "(", "n_var", "==", "2", ")", "{", "new_rtx", "=", "gen_rtx_VEC_CONCAT", "(", "V2SFmode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ";", "emit_move_insn", "(", "target", ",", "new_rtx", ")", ";", "return", ";", "}", "op1", "=", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ";", "op2", "=", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ";", "constant_op", "=", "(", "CONSTANT_P", "(", "op1", ")", ")", "?", "op1", ":", "op2", ";", "tmp", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "constant_op", ")", ")", ";", "emit_move_insn", "(", "tmp", ",", "constant_op", ")", ";", "if", "(", "CONSTANT_P", "(", "op1", ")", ")", "new_rtx", "=", "gen_rtx_VEC_CONCAT", "(", "V2SFmode", ",", "tmp", ",", "op2", ")", ";", "else", "new_rtx", "=", "gen_rtx_VEC_CONCAT", "(", "V2SFmode", ",", "op1", ",", "tmp", ")", ";", "emit_move_insn", "(", "target", ",", "new_rtx", ")", ";", "}", "</s>" ]

[ "Initialize", "TARGET", "of", "vector", "PAIRED", "to", "VALS", "." ]

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

[]

[ "<s>", "void", "OpenRISCFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC" ]

[]

[ "<s>", "static", "tree", "tilepro_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "TILEPRO_BUILTIN_max", ")", "return", "error_mark_node", ";", "return", "tilepro_builtin_info", "[", "code", "]", ".", "fndecl", ";", "}", "</s>" ]

[ "Implement", "TARGET_BUILTIN_DECL", "." ]

[ "tilepro" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Store Results\"" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalNTLoad", "(", "Type", "*", "DataType", ",", "Align", "Alignment", ")", "{", "unsigned", "DataSize", "=", "DL", ".", "getTypeStoreSize", "(", "DataType", ")", ";", "if", "(", "Alignment", ">=", "DataSize", "&&", "(", "DataSize", "==", "16", "||", "DataSize", "==", "32", ")", ")", "return", "DataSize", "==", "16", "?", "ST", "->", "hasSSE1", "(", ")", ":", "ST", "->", "hasAVX2", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "nontemporal", "load", "." ]

[ "X86", "X86", "16", "32", "16" ]

[]

[ "<s>", "static", "int", "out_set_stack_ptr", "(", "FILE", "*", "file", ",", "int", "before", ",", "int", "after", ")", "{", "int", "do_sph", ",", "do_cli", ",", "do_save", ",", "do_sei", ",", "lock_sph", ",", "size", ";", "do_sph", "=", "!", "TARGET_TINY_STACK", ";", "lock_sph", "=", "do_sph", "&&", "!", "TARGET_NO_INTERRUPTS", ";", "do_cli", "=", "(", "before", "!=", "0", "&&", "(", "after", "==", "0", "||", "lock_sph", ")", ")", ";", "do_save", "=", "(", "do_cli", "&&", "before", "==", "-", "1", "&&", "after", "==", "-", "1", ")", ";", "do_sei", "=", "(", "(", "do_cli", "||", "before", "!=", "1", ")", "&&", "after", "==", "1", ")", ";", "size", "=", "1", ";", "if", "(", "do_save", ")", "{", "fprintf", "(", "file", ",", "AS2", "(", "in", ",", "__tmp_reg__", ",", "__SREG__", ")", "CR_TAB", ")", ";", "size", "++", ";", "}", "if", "(", "do_cli", ")", "{", "fprintf", "(", "file", ",", "\"cli\"", "CR_TAB", ")", ";", "size", "++", ";", "}", "if", "(", "do_sph", ")", "{", "fprintf", "(", "file", ",", "AS2", "(", "out", ",", "__SP_H__", ",", "r29", ")", "CR_TAB", ")", ";", "size", "++", ";", "}", "if", "(", "do_save", ")", "{", "fprintf", "(", "file", ",", "AS2", "(", "out", ",", "__SREG__", ",", "__tmp_reg__", ")", "CR_TAB", ")", ";", "size", "++", ";", "}", "else", "if", "(", "do_sei", ")", "{", "fprintf", "(", "file", ",", "\"sei\"", "CR_TAB", ")", ";", "size", "++", ";", "}", "fprintf", "(", "file", ",", "AS2", "(", "out", ",", "__SP_L__", ",", "r28", ")", "\"\\n\"", ")", ";", "return", "size", ";", "}", "</s>" ]

[ "Output", "to", "FILE", "the", "asm", "instructions", "to", "copy", "r29", ":", "r28", "to", "SPH", ":", "SPL", ",", "handling", "various", "cases", "of", "interrupt", "enable", "flag", "state", "BEFORE", "and", "AFTER", "(", "0=disabled", ",", "1=enabled", ",", "-1=unknown/unchanged", ")", "and", "target_flags", ".", "Returns", "the", "number", "of", "instructions", "generated", "." ]

[ "avr", "0", "0", "1", "1", "1", "1", "1", "\"cli\"", "\"sei\"", "\"\\n\"" ]

[]

[ "<s>", "static", "inline", "bool", "general_or_i64_p", "(", "reg_class_t", "rclass", ")", "{", "return", "(", "rclass", "==", "GENERAL_REGS", "||", "rclass", "==", "I64_REGS", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "CLASS", "is", "either", "GENERAL_REGS", "or", "I64_REGS", "." ]

[ "sparc" ]

[]

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

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

[ "TGSI" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "aarch64_handle_attr_cpu", "(", "const", "char", "*", "str", ")", "{", "const", "struct", "processor", "*", "tmp_cpu", "=", "NULL", ";", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_cpu", "(", "str", ",", "&", "tmp_cpu", ",", "&", "aarch64_isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "{", "gcc_assert", "(", "tmp_cpu", ")", ";", "selected_tune", "=", "tmp_cpu", ";", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "selected_arch", "=", "&", "all_architectures", "[", "tmp_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "return", "true", ";", "}", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing name in %<target(\\\"cpu=\\\")%> pragma or attribute\"", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"invalid name (\\\"%s\\\") in %<target(\\\"cpu=\\\")%> pragma or attribute\"", ",", "str", ")", ";", "aarch64_print_hint_for_core", "(", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid value (\\\"%s\\\") in %<target()%> pragma or attribute\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Handle", "the", "argument", "CPU_STR", "to", "the", "cpu=", "target", "attribute", ".", "PRAGMA_OR_ATTR", "is", "used", "in", "potential", "error", "messages", "." ]

[ "aarch64", "\"missing name in %<target(\\\"cpu=\\\")%> pragma or attribute\"", "\"invalid name (\\\"%s\\\") in %<target(\\\"cpu=\\\")%> pragma or attribute\"", "\"invalid value (\\\"%s\\\") in %<target()%> pragma or attribute\"" ]

[]

[ "<s>", "void", "x86_elf_aligned_common", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "int", "align", ")", "{", "if", "(", "(", "ix86_cmodel", "==", "CM_MEDIUM", "||", "ix86_cmodel", "==", "CM_MEDIUM_PIC", ")", "&&", "size", ">", "(", "unsigned", "int", ")", "ix86_section_threshold", ")", "fputs", "(", "\"\\t.largecomm\\t\"", ",", "file", ")", ";", "else", "fputs", "(", "COMMON_ASM_OP", ",", "file", ")", ";", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\",\"", "HOST_WIDE_INT_PRINT_UNSIGNED", "\",%u\\n\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "This", "says", "how", "to", "output", "assembler", "code", "to", "declare", "an", "uninitialized", "external", "linkage", "data", "object", ".", "For", "medium", "model", "x86-64", "we", "need", "to", "use", ".largecomm", "opcode", "for", "large", "objects", "." ]

[ "i386", "\"\\t.largecomm\\t\"", "\",\"", "\",%u\\n\"" ]

[]

[ "<s>", "static", "void", "*", "mingw32_gt_pch_get_address", "(", "size_t", "size", ",", "int", "fd", "ATTRIBUTE_UNUSED", ")", "{", "void", "*", "res", ";", "size", "=", "(", "size", "+", "va_granularity", "-", "1", ")", "&", "~", "(", "va_granularity", "-", "1", ")", ";", "if", "(", "size", ">", "pch_VA_max_size", ")", "return", "NULL", ";", "res", "=", "VirtualAlloc", "(", "NULL", ",", "pch_VA_max_size", ",", "MEM_RESERVE", "|", "MEM_TOP_DOWN", ",", "PAGE_NOACCESS", ")", ";", "if", "(", "!", "res", ")", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"VirtualAlloc\"", ")", ";", "else", "VirtualFree", "(", "res", ",", "0", ",", "MEM_RELEASE", ")", ";", "return", "res", ";", "}", "</s>" ]

[ "Identify", "an", "address", "that", "'s", "likely", "to", "be", "free", "in", "a", "subsequent", "invocation", "of", "the", "compiler", ".", "The", "area", "should", "be", "able", "to", "hold", "SIZE", "bytes", ".", "FD", "is", "an", "open", "file", "descriptor", "if", "the", "host", "would", "like", "to", "probe", "with", "mmap", "." ]

[ "i386", "1", "1", "\"VirtualAlloc\"", "0" ]

[]

[ "<s>", "int", "fr30_num_arg_regs", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "int", "size", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "if", "(", "type", "&&", "mode", "==", "BLKmode", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "word", "sized", "registers", "needed", "to", "hold", "a", "function", "argument", "of", "mode", "INT_MODE", "and", "tree", "type", "TYPE", "." ]

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

[]

[ "<s>", "bool", "ARM64TargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", ";", "SDValue", "Ptr", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "IsInc", ";", "if", "(", "!", "getIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "Base", ",", "Offset", ",", "AM", ",", "IsInc", ",", "DAG", ")", ")", "return", "false", ";", "AM", "=", "IsInc", "?", "ISD", "::", "PRE_INC", ":", "ISD", "::", "PRE_DEC", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ISD::MemIndexedMode", "ISD::PRE_INC", "ISD::PRE_DEC" ]

[]

[ "<s>", "void", "ia64_unpack_assemble", "(", "rtx", "out", ",", "rtx", "lo", ",", "rtx", "hi", ",", "bool", "highp", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "lo", ")", ";", "unsigned", "int", "i", ",", "high", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "struct", "expand_vec_perm_d", "d", ";", "bool", "ok", ";", "d", ".", "target", "=", "gen_lowpart", "(", "vmode", ",", "out", ")", ";", "d", ".", "op0", "=", "(", "TARGET_BIG_ENDIAN", "?", "hi", ":", "lo", ")", ";", "d", ".", "op1", "=", "(", "TARGET_BIG_ENDIAN", "?", "lo", ":", "hi", ")", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "nelt", "=", "nelt", ";", "d", ".", "one_operand_p", "=", "false", ";", "d", ".", "testing_p", "=", "false", ";", "high", "=", "(", "highp", "?", "nelt", "/", "2", ":", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", "/", "2", ";", "++", "i", ")", "{", "d", ".", "perm", "[", "i", "*", "2", "]", "=", "i", "+", "high", ";", "d", ".", "perm", "[", "i", "*", "2", "+", "1", "]", "=", "i", "+", "high", "+", "nelt", ";", "}", "ok", "=", "ia64_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "gcc_assert", "(", "ok", ")", ";", "}", "</s>" ]

[ "The", "vectors", "LO", "and", "HI", "each", "contain", "N", "halves", "of", "a", "double-wide", "vector", ".", "Reassemble", "either", "the", "first", "N/2", "or", "the", "second", "N/2", "elements", "." ]

[ "ia64", "2", "0", "0", "2", "2", "2", "1" ]

[]

[ "<s>", "EVT", "TVMTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", ",", "unsigned", ",", "unsigned", ",", "bool", ",", "bool", ",", "bool", ",", "MachineFunction", "&", ")", "const", "{", "return", "MVT", "::", "i257", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "MVT::i257" ]

[]

[ "<s>", "static", "void", "register_vector_type", "(", "vector_type_index", "type", ")", "{", "tree", "vectype", "=", "abi_vector_types", "[", "type", "]", ";", "tree", "id", "=", "get_identifier", "(", "vector_types", "[", "type", "]", ".", "acle_name", ")", ";", "tree", "decl", "=", "build_decl", "(", "input_location", ",", "TYPE_DECL", ",", "id", ",", "vectype", ")", ";", "decl", "=", "lang_hooks", ".", "decls", ".", "pushdecl", "(", "decl", ")", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "TYPE_DECL", "&&", "TYPE_MAIN_VARIANT", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "vectype", ")", "vectype", "=", "TREE_TYPE", "(", "decl", ")", ";", "acle_vector_types", "[", "0", "]", "[", "type", "]", "=", "vectype", ";", "}", "</s>" ]

[ "Register", "vector", "type", "TYPE", "under", "its", "risv_vector.h", "name", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "ARMTargetLowering", "::", "HandleByVal", "(", "CCState", "*", "State", ",", "unsigned", "&", "size", ",", "unsigned", "Align", ")", "const", "{", "unsigned", "reg", "=", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ";", "assert", "(", "(", "State", "->", "getCallOrPrologue", "(", ")", "==", "Prologue", "||", "State", "->", "getCallOrPrologue", "(", ")", "==", "Call", ")", "&&", "\"unhandled ParmContext\"", ")", ";", "if", "(", "(", "!", "State", "->", "isFirstByValRegValid", "(", ")", ")", "&&", "(", "ARM", "::", "R0", "<=", "reg", ")", "&&", "(", "reg", "<=", "ARM", "::", "R3", ")", ")", "{", "if", "(", "Subtarget", "->", "isAAPCS_ABI", "(", ")", "&&", "Align", ">", "4", ")", "{", "unsigned", "AlignInRegs", "=", "Align", "/", "4", ";", "unsigned", "Waste", "=", "(", "ARM", "::", "R4", "-", "reg", ")", "%", "AlignInRegs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Waste", ";", "++", "i", ")", "reg", "=", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ";", "}", "if", "(", "reg", "!=", "0", ")", "{", "State", "->", "setFirstByValReg", "(", "reg", ")", ";", "if", "(", "State", "->", "getCallOrPrologue", "(", ")", "==", "Call", ")", "{", "unsigned", "excess", "=", "4", "*", "(", "ARM", "::", "R4", "-", "reg", ")", ";", "assert", "(", "size", ">=", "excess", "&&", "\"expected larger existing stack allocation\"", ")", ";", "size", "-=", "excess", ";", "}", "}", "}", "while", "(", "State", "->", "AllocateReg", "(", "GPRArgRegs", ",", "4", ")", ")", ";", "}", "</s>" ]

[ "Target-specific", "cleanup", "for", "formal", "ByVal", "parameters", "." ]

[ "ARM", "ARM", "4", "\"unhandled ParmContext\"", "ARM::R0", "ARM::R3", "4", "4", "ARM::R4", "0", "4", "0", "4", "ARM::R4", "\"expected larger existing stack allocation\"", "4" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getCacheLineSize", "(", ")", "const", "{", "if", "(", "CacheLineSize", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "return", "CacheLineSize", ";", "unsigned", "Directive", "=", "ST", "->", "getCPUDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", "||", "Directive", "==", "PPC", "::", "DIR_PWR9", "||", "Directive", "==", "PPC", "::", "DIR_PWR10", "||", "Directive", "==", "PPC", "::", "DIR_PWR_FUTURE", ")", "return", "128", ";", "return", "64", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "PowerPC", "PPC", "0", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "PPC::DIR_PWR10", "PPC::DIR_PWR_FUTURE", "128", "64" ]

[]

[ "<s>", "rtx", "m68k_libcall_value", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "SFmode", ":", "case", "DFmode", ":", "case", "XFmode", ":", "if", "(", "TARGET_68881", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP0_REG", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "m68k_libcall_value_in_a0_p", "?", "A0_REG", ":", "D0_REG", ")", ";", "}", "</s>" ]

[ "Return", "floating", "point", "values", "in", "a", "68881", "register", ".", "This", "makes", "68881", "code", "a", "little", "bit", "faster", ".", "It", "also", "makes", "-msoft-float", "code", "incompatible", "with", "hard-float", "code", ",", "so", "people", "have", "to", "be", "careful", "not", "to", "mix", "the", "two", ".", "For", "ColdFire", "it", "was", "decided", "the", "ABI", "incompatibility", "is", "undesirable", ".", "If", "there", "is", "need", "for", "a", "hard-float", "ABI", "it", "is", "probably", "worth", "doing", "it", "properly", "and", "also", "passing", "function", "arguments", "in", "FP", "registers", "." ]

[ "m68k" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"X86-64 PIC uses RIP relative addressing\"", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", "->", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "X86FI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "X86", "::", "GR32_NOSPRegClass", ")", ";", "X86FI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"X86-64 PIC uses RIP relative addressing\"", "X86", "X86", "X86", "X86", "0", "X86::GR32_NOSPRegClass", "X86" ]

[]

[ "<s>", "BitVector", "DLXRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "DLX", "::", "RA", ")", ";", "Reserved", ".", "set", "(", "DLX", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "DLX", "::", "SP", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "getBaseRegister", "(", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "DLX", "DLX", "DLX::RA", "DLX::FP", "DLX::SP" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "bool", "C", "=", "false", ";", "TargetMachine", "*", "TM", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "TargetLibraryInfo", "*", "TLI", "=", "&", "getAnalysis", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ".", "getTLI", "(", "F", ")", ";", "X86LowerAMXCast", "LAC", "(", "F", ")", ";", "C", "|=", "LAC", ".", "combineAMXcast", "(", "TLI", ")", ";", "C", "|=", "LAC", ".", "transformAllAMXCast", "(", ")", ";", "X86LowerAMXType", "LAT", "(", "F", ")", ";", "C", "|=", "LAT", ".", "visit", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "OptimizeNone", ")", ")", "{", "X86VolatileTileData", "VTD", "(", "F", ")", ";", "C", "=", "VTD", ".", "volatileTileData", "(", ")", "||", "C", ";", "}", "}", "return", "C", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "SITargetLowering", "::", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getScalarType", "(", ")", ".", "bitsLE", "(", "MVT", "::", "i16", ")", ")", "return", "TypeSplitVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "R600", "SI", "1", "MVT::i16" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "HST", "=", "&", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "HII", "=", "HST", "->", "getInstrInfo", "(", ")", ";", "HRI", "=", "HST", "->", "getRegisterInfo", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "updateAligna", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "msp430_fixup_compare_operands", "(", "machine_mode", "my_mode", ",", "rtx", "*", "operands", ")", "{", "int", "const_op_idx", "=", "1", ";", "if", "(", "msp430_reversible_cmp_operator", "(", "operands", "[", "0", "]", ",", "VOIDmode", ")", ")", "const_op_idx", "=", "2", ";", "if", "(", "GET_CODE", "(", "operands", "[", "const_op_idx", "]", ")", "!=", "REG", "&&", "GET_CODE", "(", "operands", "[", "const_op_idx", "]", ")", "!=", "MEM", ")", "operands", "[", "const_op_idx", "]", "=", "copy_to_mode_reg", "(", "my_mode", ",", "operands", "[", "const_op_idx", "]", ")", ";", "}", "</s>" ]

[ "Called", "by", "cbranch", "<", "mode", ">", "4", "to", "coerce", "operands", "into", "usable", "forms", "." ]

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

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "advanceTo", "(", "MachineBasicBlock", "::", "iterator", "NextBegin", ")", "{", "MachineBasicBlock", "::", "iterator", "LastEmittedMI", "=", "HazardRec", "->", "getLastEmittedMI", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "(", "(", "LastEmittedMI", "!=", "nullptr", "&&", "LastEmittedMI", "->", "getParent", "(", ")", "==", "MBB", ")", "?", "std", "::", "next", "(", "LastEmittedMI", ")", ":", "MBB", "->", "begin", "(", ")", ")", ";", "for", "(", ";", "I", "!=", "NextBegin", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isPosition", "(", ")", "||", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "HazardRec", "->", "emitInstruction", "(", "&", "*", "I", ")", ";", "}", "}", "</s>" ]

[ "advanceTo", "-", "Advance", "the", "specified", "iterator", "to", "point", "to", "the", "Segment", "containing", "the", "specified", "position", ",", "or", "end", "(", ")", "if", "the", "position", "is", "past", "the", "end", "of", "the", "range", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetSubtargetInfo", "&", "STM", "=", "MF", ".", "getSubtarget", "(", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "STM", ".", "getRegisterInfo", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "STM", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "assert", "(", "!", "MRI", "->", "isSSA", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "\"Running SILoadStoreOptimizer\\n\"" ]

[]

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

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

[ "VideoCore4", "VideoCore4" ]

[]

[ "<s>", "const", "char", "*", "tilegx_output_cbranch", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operands", ",", "bool", "reversed", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "const", "char", "*", "opcode", ";", "const", "char", "*", "rev_opcode", ";", "if", "(", "reversed", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "NE", ":", "opcode", "=", "\"bnez\"", ";", "rev_opcode", "=", "\"beqz\"", ";", "break", ";", "case", "EQ", ":", "opcode", "=", "\"beqz\"", ";", "rev_opcode", "=", "\"bnez\"", ";", "break", ";", "case", "GE", ":", "opcode", "=", "\"bgez\"", ";", "rev_opcode", "=", "\"bltz\"", ";", "break", ";", "case", "GT", ":", "opcode", "=", "\"bgtz\"", ";", "rev_opcode", "=", "\"blez\"", ";", "break", ";", "case", "LE", ":", "opcode", "=", "\"blez\"", ";", "rev_opcode", "=", "\"bgtz\"", ";", "break", ";", "case", "LT", ":", "opcode", "=", "\"bltz\"", ";", "rev_opcode", "=", "\"bgez\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "tilegx_output_cbranch_with_opcode", "(", "insn", ",", "operands", ",", "opcode", ",", "rev_opcode", ",", "2", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "code", "for", "a", "conditional", "branch", "instruction", "." ]

[ "tilegx", "1", "\"bnez\"", "\"beqz\"", "\"beqz\"", "\"bnez\"", "\"bgez\"", "\"bltz\"", "\"bgtz\"", "\"blez\"", "\"blez\"", "\"bgtz\"", "\"bltz\"", "\"bgez\"", "2" ]

[]

[ "<s>", "static", "void", "arc_add_jli_section", "(", "rtx", "pat", ")", "{", "const", "char", "*", "name", ";", "tree", "attrs", ";", "arc_jli_section", "*", "sec", "=", "arc_jli_sections", ",", "*", "new_section", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "pat", ")", ";", "if", "(", "!", "pat", ")", "return", ";", "if", "(", "decl", ")", "{", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "lookup_attribute", "(", "\"jli_fixed\"", ",", "attrs", ")", ")", "return", ";", "}", "name", "=", "XSTR", "(", "pat", ",", "0", ")", ";", "while", "(", "sec", "!=", "NULL", ")", "{", "if", "(", "strcmp", "(", "name", ",", "sec", "->", "name", ")", "==", "0", ")", "return", ";", "sec", "=", "sec", "->", "next", ";", "}", "new_section", "=", "(", "arc_jli_section", "*", ")", "xmalloc", "(", "sizeof", "(", "arc_jli_section", ")", ")", ";", "gcc_assert", "(", "new_section", "!=", "NULL", ")", ";", "new_section", "->", "name", "=", "name", ";", "new_section", "->", "next", "=", "arc_jli_sections", ";", "arc_jli_sections", "=", "new_section", ";", "}", "</s>" ]

[ "Add", "the", "given", "function", "declaration", "to", "emit", "code", "in", "JLI", "section", "." ]

[ "arc", "\"jli_fixed\"", "0", "0" ]

[]

[ "<s>", "unsigned", "int", "AMDGPUIntrinsicInfo", "::", "lookupName", "(", "const", "char", "*", "Name", ",", "unsigned", "int", "Len", ")", "const", "{", "if", "(", "!", "StringRef", "(", "Name", ",", "Len", ")", ".", "startswith", "(", "\"llvm.\"", ")", ")", "return", "0", ";", "AMDGPUIntrinsic", "::", "ID", "IntrinsicID", "=", "(", "AMDGPUIntrinsic", "::", "ID", ")", "Intrinsic", "::", "not_intrinsic", ";", "IntrinsicID", "=", "getIntrinsicForGCCBuiltin", "(", "\"AMDGPU\"", ",", "Name", ")", ";", "if", "(", "IntrinsicID", "!=", "(", "AMDGPUIntrinsic", "::", "ID", ")", "Intrinsic", "::", "not_intrinsic", ")", "{", "return", "IntrinsicID", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Look", "up", "target", "intrinsic", "by", "name", "." ]

[ "R600", "\"llvm.\"", "0", "AMDGPUIntrinsic::ID", "AMDGPUIntrinsic::ID", "Intrinsic::not_intrinsic", "\"AMDGPU\"", "AMDGPUIntrinsic::ID", "Intrinsic::not_intrinsic", "0" ]

[]

[ "<s>", "bool", "hasTailCall", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpc", "=", "I", "->", "getOpcode", "(", ")", ";", "return", "RetOpc", "==", "Hexagon", "::", "TCRETURNi", "||", "RetOpc", "==", "Hexagon", "::", "TCRETURNr", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "function", "contains", "a", "tail", "call", "." ]

[ "Hexagon", "Hexagon::TCRETURNi", "Hexagon::TCRETURNr" ]

[]

[ "<s>", "static", "int", "epilogue_renumber", "(", "rtx", "*", "where", ",", "int", "test", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "enum", "rtx_code", "code", ";", "if", "(", "*", "where", "==", "0", ")", "return", "0", ";", "code", "=", "GET_CODE", "(", "*", "where", ")", ";", "switch", "(", "code", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "*", "where", ")", ">=", "8", "&&", "REGNO", "(", "*", "where", ")", "<", "24", ")", "return", "1", ";", "if", "(", "!", "test", "&&", "REGNO", "(", "*", "where", ")", ">=", "24", "&&", "REGNO", "(", "*", "where", ")", "<", "32", ")", "*", "where", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "*", "where", ")", ",", "OUTGOING_REGNO", "(", "REGNO", "(", "*", "where", ")", ")", ")", ";", "case", "SCRATCH", ":", "case", "CC0", ":", "case", "PC", ":", "case", "CONST_INT", ":", "case", "CONST_WIDE_INT", ":", "case", "CONST_DOUBLE", ":", "return", "0", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "*", "where", ",", "1", ")", ")", "<", "SPARC_STACK_BIAS", ")", ")", "return", "1", ";", "break", ";", "case", "MEM", ":", "if", "(", "SPARC_STACK_BIAS", "&&", "GET_CODE", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "*", "where", ",", "0", ")", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "1", ";", "break", ";", "default", ":", "break", ";", "}", "fmt", "=", "GET_RTX_FORMAT", "(", "code", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "code", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "*", "where", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "epilogue_renumber", "(", "&", "(", "XVECEXP", "(", "*", "where", ",", "i", ",", "j", ")", ")", ",", "test", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "epilogue_renumber", "(", "&", "(", "XEXP", "(", "*", "where", ",", "i", ")", ")", ",", "test", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", ",", "if", "any", "of", "the", "registers", "of", "the", "instruction", "are", "%", "l", "[", "0-7", "]", "or", "%", "o", "[", "0-7", "]", ".", "Such", "instructions", "can", "not", "be", "used", "in", "the", "delay", "slot", "of", "return", "insn", "on", "v9", ".", "If", "TEST", "is", "0", ",", "also", "rename", "all", "%", "i", "[", "0-7", "]", "registers", "to", "their", "%", "o", "[", "0-7", "]", "counterparts", "." ]

[ "sparc", "0", "0", "8", "24", "1", "24", "32", "0", "0", "0", "1", "1", "1", "0", "0", "1", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addPreISel", "(", ")", "{", "AMDGPUPassConfig", "::", "addPreISel", "(", ")", ";", "if", "(", "EnableAtomicOptimizations", ")", "{", "addPass", "(", "createAMDGPUAtomicOptimizerPass", "(", ")", ")", ";", "}", "addPass", "(", "&", "AMDGPUUnifyDivergentExitNodesID", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createStructurizeCFGPass", "(", "true", ")", ")", ";", "}", "addPass", "(", "createSinkingPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAnnotateUniformValues", "(", ")", ")", ";", "if", "(", "!", "LateCFGStructurize", ")", "{", "addPass", "(", "createSIAnnotateControlFlowPass", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "getMemIntrinsicNode", "(", "unsigned", "Opcode", ",", "const", "SDLoc", "&", "DL", ",", "SDVTList", "VTList", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ",", "EVT", "MemVT", ",", "MachineMemOperand", "*", "MMO", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "VTList", ".", "VTs", "[", "0", "]", ";", "EVT", "WidenedVT", "=", "VT", ";", "EVT", "WidenedMemVT", "=", "MemVT", ";", "if", "(", "!", "Subtarget", "->", "hasDwordx3LoadStores", "(", ")", "&&", "(", "WidenedVT", "==", "MVT", "::", "v3i32", "||", "WidenedVT", "==", "MVT", "::", "v3f32", ")", ")", "{", "WidenedVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedVT", ".", "getVectorElementType", "(", ")", ",", "4", ")", ";", "WidenedMemVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "WidenedMemVT", ".", "getVectorElementType", "(", ")", ",", "4", ")", ";", "MMO", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getMachineMemOperand", "(", "MMO", ",", "0", ",", "16", ")", ";", "}", "assert", "(", "VTList", ".", "NumVTs", "==", "2", ")", ";", "SDVTList", "WidenedVTList", "=", "DAG", ".", "getVTList", "(", "WidenedVT", ",", "VTList", ".", "VTs", "[", "1", "]", ")", ";", "auto", "NewOp", "=", "DAG", ".", "getMemIntrinsicNode", "(", "Opcode", ",", "DL", ",", "WidenedVTList", ",", "Ops", ",", "WidenedMemVT", ",", "MMO", ")", ";", "if", "(", "WidenedVT", "!=", "VT", ")", "{", "auto", "Extract", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_SUBVECTOR", ",", "DL", ",", "VT", ",", "NewOp", ",", "DAG", ".", "getVectorIdxConstant", "(", "0", ",", "DL", ")", ")", ";", "NewOp", "=", "DAG", ".", "getMergeValues", "(", "{", "Extract", ",", "SDValue", "(", "NewOp", ".", "getNode", "(", ")", ",", "1", ")", "}", ",", "DL", ")", ";", "}", "return", "NewOp", ";", "}", "</s>" ]

[ "Creates", "a", "MemIntrinsicNode", "that", "may", "produce", "a", "result", "and", "takes", "a", "list", "of", "operands", "." ]

[ "AMDGPU", "SI", "0", "MVT::v3i32", "MVT::v3f32", "4", "4", "0", "16", "2", "1", "ISD::EXTRACT_SUBVECTOR", "0", "1" ]

[]

[ "<s>", "bool", "s390_const_operand_ok", "(", "tree", "arg", ",", "int", "argnum", ",", "int", "op_flags", ",", "tree", "decl", ")", "{", "if", "(", "O_UIMM_P", "(", "op_flags", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "bitwidths", "[", "]", "=", "{", "1", ",", "2", ",", "3", ",", "4", ",", "5", ",", "8", ",", "12", ",", "16", ",", "32", ",", "4", ",", "4", "}", ";", "unsigned", "HOST_WIDE_INT", "bitmasks", "[", "]", "=", "{", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "0", ",", "5", ",", "12", "}", ";", "unsigned", "HOST_WIDE_INT", "bitwidth", "=", "bitwidths", "[", "op_flags", "-", "O_U1", "]", ";", "unsigned", "HOST_WIDE_INT", "bitmask", "=", "bitmasks", "[", "op_flags", "-", "O_U1", "]", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "tree_to_uhwi", "(", "arg", ")", ">", "(", "HOST_WIDE_INT_1U", "<<", "bitwidth", ")", "-", "1", "||", "(", "bitmask", "&&", "tree_to_uhwi", "(", "arg", ")", "&", "~", "bitmask", ")", ")", "{", "if", "(", "bitmask", ")", "{", "gcc_assert", "(", "bitmask", "<", "16", ")", ";", "char", "values", "[", "120", "]", "=", "\"\"", ";", "for", "(", "unsigned", "HOST_WIDE_INT", "i", "=", "0", ";", "i", "<=", "bitmask", ";", "i", "++", ")", "{", "char", "buf", "[", "5", "]", ";", "if", "(", "i", "&", "~", "bitmask", ")", "continue", ";", "int", "ret", "=", "snprintf", "(", "buf", ",", "5", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "i", "&", "bitmask", ")", ";", "gcc_assert", "(", "ret", "<", "5", ")", ";", "strcat", "(", "values", ",", "buf", ")", ";", "if", "(", "i", "<", "bitmask", ")", "strcat", "(", "values", ",", "\", \"", ")", ";", "}", "error", "(", "\"constant argument %d for builtin %qF is invalid (%s)\"", ",", "argnum", ",", "decl", ",", "values", ")", ";", "}", "else", "error", "(", "\"constant argument %d for builtin %qF is out of range (0..%wu)\"", ",", "argnum", ",", "decl", ",", "(", "HOST_WIDE_INT_1U", "<<", "bitwidth", ")", "-", "1", ")", ";", "return", "false", ";", "}", "}", "if", "(", "O_SIMM_P", "(", "op_flags", ")", ")", "{", "int", "bitwidths", "[", "]", "=", "{", "2", ",", "3", ",", "4", ",", "5", ",", "8", ",", "12", ",", "16", ",", "32", "}", ";", "int", "bitwidth", "=", "bitwidths", "[", "op_flags", "-", "O_S2", "]", ";", "if", "(", "!", "tree_fits_shwi_p", "(", "arg", ")", "||", "tree_to_shwi", "(", "arg", ")", "<", "-", "(", "HOST_WIDE_INT_1", "<<", "(", "bitwidth", "-", "1", ")", ")", "||", "tree_to_shwi", "(", "arg", ")", ">", "(", "(", "HOST_WIDE_INT_1", "<<", "(", "bitwidth", "-", "1", ")", ")", "-", "1", ")", ")", "{", "error", "(", "\"constant argument %d for builtin %qF is out of range \"", "\"(%wd..%wd)\"", ",", "argnum", ",", "decl", ",", "-", "(", "HOST_WIDE_INT_1", "<<", "(", "bitwidth", "-", "1", ")", ")", ",", "(", "HOST_WIDE_INT_1", "<<", "(", "bitwidth", "-", "1", ")", ")", "-", "1", ")", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "ARG", "is", "appropriate", "as", "argument", "number", "ARGNUM", "of", "builtin", "DECL", ".", "The", "operand", "flags", "from", "s390-builtins.def", "have", "to", "passed", "as", "OP_FLAGS", "." ]

[ "s390", "1", "2", "3", "4", "5", "8", "12", "16", "32", "4", "4", "0", "0", "0", "0", "0", "0", "0", "0", "0", "5", "12", "1", "16", "120", "\"\"", "0", "5", "5", "5", "\", \"", "\"constant argument %d for builtin %qF is invalid (%s)\"", "\"constant argument %d for builtin %qF is out of range (0..%wu)\"", "1", "2", "3", "4", "5", "8", "12", "16", "32", "1", "1", "1", "\"constant argument %d for builtin %qF is out of range \"", "\"(%wd..%wd)\"", "1", "1", "1" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "ExpandMOVSZX_RM", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "IsSigned", ",", "const", "MCInstrDesc", "&", "Desc", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to LOAD and \"", ")", ";", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubDst", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "MVTSrc", "==", "MVT", "::", "i8", "?", "M68k", "::", "MxSubRegIndex8Lo", ":", "M68k", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "SubDst", "&&", "\"No viable SUB register available\"", ")", ";", "MIB", "->", "setDesc", "(", "Desc", ")", ";", "MIB", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "SubDst", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "I", "++", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "IsSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Move", "from", "memory", "and", "extend", "." ]

[ "M68k", "M68k", "\"Expand \"", "\" to LOAD and \"", "0", "MVT::i8", "M68k::MxSubRegIndex8Lo", "M68k::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "0", "\"Sign Extend\"", "\"Zero Extend\"" ]

[]

[ "<s>", "void", "RISCVAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "LowerRISCVMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "bool", "HasStdExtC", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "if", "(", "(", "Count", "%", "MinNopLen", ")", "!=", "0", ")", "return", "false", ";", "uint64_t", "Nop32Count", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "Nop32Count", ";", "i", "!=", "0", ";", "--", "i", ")", "OW", "->", "write32", "(", "0x13", ")", ";", "if", "(", "HasStdExtC", ")", "{", "uint64_t", "Nop16Count", "=", "(", "Count", "-", "Nop32Count", "*", "4", ")", "/", "2", ";", "for", "(", "uint64_t", "i", "=", "Nop16Count", ";", "i", "!=", "0", ";", "--", "i", ")", "OW", "->", "write16", "(", "0x01", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureStdExtC", "2", "4", "0", "4", "0", "0x13", "4", "2", "0", "0x01" ]

[]

[ "<s>", "void", "aarch64_subvti_scratch_regs", "(", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "*", "low_dest", ",", "rtx", "*", "low_in1", ",", "rtx", "*", "low_in2", ",", "rtx", "*", "high_dest", ",", "rtx", "*", "high_in1", ",", "rtx", "*", "high_in2", ")", "{", "*", "low_dest", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "*", "low_in1", "=", "simplify_gen_subreg", "(", "DImode", ",", "op1", ",", "TImode", ",", "subreg_lowpart_offset", "(", "DImode", ",", "TImode", ")", ")", ";", "*", "low_in2", "=", "simplify_gen_subreg", "(", "DImode", ",", "op2", ",", "TImode", ",", "subreg_lowpart_offset", "(", "DImode", ",", "TImode", ")", ")", ";", "*", "high_dest", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "*", "high_in1", "=", "simplify_gen_subreg", "(", "DImode", ",", "op1", ",", "TImode", ",", "subreg_highpart_offset", "(", "DImode", ",", "TImode", ")", ")", ";", "*", "high_in2", "=", "simplify_gen_subreg", "(", "DImode", ",", "op2", ",", "TImode", ",", "subreg_highpart_offset", "(", "DImode", ",", "TImode", ")", ")", ";", "}", "</s>" ]

[ "Generate", "DImode", "scratch", "registers", "for", "128-bit", "(", "TImode", ")", "subtraction", ".", "This", "function", "differs", "from", "'arch64_addti_scratch_regs", "'", "in", "that", "OP1", "can", "be", "an", "immediate", "constant", "(", "zero", ")", ".", "We", "must", "call", "subreg_highpart_offset", "with", "DImode", "and", "TImode", "arguments", ",", "otherwise", "VOIDmode", "will", "be", "used", "for", "the", "const_int", "which", "generates", "an", "internal", "error", "from", "subreg_size_highpart_offset", "which", "does", "not", "expect", "a", "size", "of", "zero", ".", "OP1", "represents", "the", "TImode", "destination", "operand", "1", "OP2", "represents", "the", "TImode", "destination", "operand", "2", "LOW_DEST", "represents", "the", "low", "half", "(", "DImode", ")", "of", "TImode", "operand", "0", "LOW_IN1", "represents", "the", "low", "half", "(", "DImode", ")", "of", "TImode", "operand", "1", "LOW_IN2", "represents", "the", "low", "half", "(", "DImode", ")", "of", "TImode", "operand", "2", "HIGH_DEST", "represents", "the", "high", "half", "(", "DImode", ")", "of", "TImode", "operand", "0", "HIGH_IN1", "represents", "the", "high", "half", "(", "DImode", ")", "of", "TImode", "operand", "1", "HIGH_IN2", "represents", "the", "high", "half", "(", "DImode", ")", "of", "TImode", "operand", "2", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "AArch64TTI", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "OperandValueKind", "Opd1Info", ",", "OperandValueKind", "Opd2Info", ",", "OperandValueProperties", "Opd1PropInfo", ",", "OperandValueProperties", "Opd2PropInfo", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "TargetTransformInfo", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "return", "1", "*", "LT", ".", "first", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "AArch64", "AArch64", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "1" ]

[]

[ "<s>", "unsigned", "PPCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "assert", "(", "(", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MTCRF8", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "PPC", "::", "MFOCRF", ")", "||", "MO", ".", "getReg", "(", ")", "<", "PPC", "::", "CR0", "||", "MO", ".", "getReg", "(", ")", ">", "PPC", "::", "CR7", ")", ";", "return", "getPPCRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isImm", "(", ")", "&&", "\"Relocation required in an instruction that we cannot encode!\"", ")", ";", "return", "MO", ".", "getImm", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::MTCRF", "PPC::MTCRF8", "PPC::MFOCRF", "PPC::CR0", "PPC::CR7", "PPC", "\"Relocation required in an instruction that we cannot encode!\"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "auto", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "Val", ")", ")", "{", "EVT", "MemVT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "(", "MemVT", "==", "MVT", "::", "i8", "||", "MemVT", "==", "MVT", "::", "i16", ")", "&&", "(", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "NON_EXTLOAD", "||", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "ZEXTLOAD", ")", ")", "return", "true", ";", "}", "return", "TargetLowering", "::", "isZExtFree", "(", "Val", ",", "VT2", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "RISCV", "RISCV", "MVT::i8", "MVT::i16", "ISD::NON_EXTLOAD", "ISD::ZEXTLOAD" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "auto", "*", "ZII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "assert", "(", "MBBI", "->", "isReturn", "(", ")", "&&", "\"Can only insert epilogue into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "getAllocatedStackSize", "(", "MF", ")", ";", "if", "(", "ZFI", "->", "getLowSavedGPR", "(", ")", ")", "{", "--", "MBBI", ";", "unsigned", "Opcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "SystemZ", "::", "LMG", ")", "llvm_unreachable", "(", "\"Expected to see callee-save register restore code\"", ")", ";", "unsigned", "AddrOpNo", "=", "2", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Offset", "=", "StackSize", "+", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "if", "(", "!", "NewOpcode", ")", "{", "uint64_t", "NumBytes", "=", "Offset", "-", "0x7fff8", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "MBBI", "->", "getOperand", "(", "AddrOpNo", ")", ".", "getReg", "(", ")", ",", "NumBytes", ",", "ZII", ")", ";", "Offset", "-=", "NumBytes", ";", "NewOpcode", "=", "ZII", "->", "getOpcodeForOffset", "(", "Opcode", ",", "Offset", ")", ";", "assert", "(", "NewOpcode", "&&", "\"No restore instruction available\"", ")", ";", "}", "MBBI", "->", "setDesc", "(", "ZII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MBBI", "->", "getOperand", "(", "AddrOpNo", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "if", "(", "StackSize", ")", "{", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "emitIncrement", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SystemZ", "::", "R15D", ",", "StackSize", ",", "ZII", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"Can only insert epilogue into returning blocks\"", "SystemZ::LMG", "\"Expected to see callee-save register restore code\"", "2", "1", "0x7fff8", "\"No restore instruction available\"", "1", "SystemZ::R15D" ]

[]

[ "<s>", "bool", "XCoreLowerThreadLocal", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "bool", "MadeChange", "=", "false", ";", "SmallVector", "<", "GlobalVariable", "*", ",", "16", ">", "ThreadLocalGlobals", ";", "for", "(", "GlobalVariable", "&", "GV", ":", "M", ".", "globals", "(", ")", ")", "if", "(", "GV", ".", "isThreadLocal", "(", ")", ")", "ThreadLocalGlobals", ".", "push_back", "(", "&", "GV", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "ThreadLocalGlobals", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MadeChange", "|=", "lowerGlobal", "(", "ThreadLocalGlobals", "[", "I", "]", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "XCore", "XCore", "16", "0" ]

[]

[ "<s>", "static", "void", "add_sched_insns_for_speculation", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "!", "ENABLE_WA_SPECULATIVE_LOADS", "&&", "!", "ENABLE_WA_SPECULATIVE_SYNCS", "&&", "!", "ENABLE_WA_INDIRECT_CALLS", ")", "return", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "pat", ";", "if", "(", "NOTE_P", "(", "insn", ")", "||", "BARRIER_P", "(", "insn", ")", "||", "LABEL_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "USE", "||", "GET_CODE", "(", "pat", ")", "==", "CLOBBER", "||", "GET_CODE", "(", "pat", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "pat", ")", ">=", "0", ")", "continue", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "{", "if", "(", "any_condjump_p", "(", "insn", ")", "&&", "!", "cbranch_predicted_taken_p", "(", "insn", ")", ")", "{", "rtx_insn", "*", "n", "=", "next_real_insn", "(", "insn", ")", ";", "emit_insn_before", "(", "gen_stall", "(", "GEN_INT", "(", "3", ")", ")", ",", "n", ")", ";", "}", "}", "}", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "any_condjump_p", "(", "insn", ")", "&&", "(", "cbranch_predicted_taken_p", "(", "insn", ")", ")", ")", "{", "rtx_insn", "*", "target", "=", "JUMP_LABEL_AS_INSN", "(", "insn", ")", ";", "rtx_insn", "*", "next", "=", "next_real_insn", "(", "target", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "next", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "get_attr_type", "(", "next", ")", "==", "TYPE_STALL", ")", "continue", ";", "emit_insn_before", "(", "gen_stall", "(", "GEN_INT", "(", "1", ")", ")", ",", "next", ")", ";", "}", "}", "}", "</s>" ]

[ "Called", "just", "before", "the", "final", "scheduling", "pass", ".", "If", "we", "need", "to", "insert", "NOPs", "later", "on", "to", "work", "around", "speculative", "loads", ",", "insert", "special", "placeholder", "insns", "that", "cause", "loads", "to", "be", "delayed", "for", "as", "many", "cycles", "as", "necessary", "(", "and", "possible", ")", ".", "This", "reduces", "the", "number", "of", "NOPs", "we", "need", "to", "add", ".", "The", "dummy", "insns", "we", "generate", "are", "later", "removed", "by", "bfin_gen_bundles", "." ]

[ "bfin", "0", "3", "1" ]

[]

[ "<s>", "unsigned", "RISCVAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "RISCVOperand", "&", "Op", "=", "static_cast", "<", "RISCVOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "return", "Match_InvalidOperand", ";", "MCRegister", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "bool", "IsRegFPR64", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR64RegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "bool", "IsRegFPR64C", "=", "RISCVMCRegisterClasses", "[", "RISCV", "::", "FPR64CRegClassID", "]", ".", "contains", "(", "Reg", ")", ";", "if", "(", "(", "IsRegFPR64", "&&", "Kind", "==", "MCK_FPR32", ")", "||", "(", "IsRegFPR64C", "&&", "Kind", "==", "MCK_FPR32C", ")", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR64ToFPR32", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "if", "(", "IsRegFPR64", "&&", "Kind", "==", "MCK_FPR16", ")", "{", "Op", ".", "Reg", ".", "RegNum", "=", "convertFPR64ToFPR16", "(", "Reg", ")", ";", "return", "Match_Success", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::FPR64RegClassID", "RISCV", "RISCV::FPR64CRegClassID" ]

[]

[ "<s>", "MVT", "SPUTargetLowering", "::", "getSetCCResultType", "(", "MVT", "VT", ")", "const", "{", "return", "(", "(", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", ")", "?", "VT", ":", "MVT", "::", "i32", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i32" ]

[]

[ "<s>", "bool", "sh_in_recog_treg_set_expr", "(", "void", ")", "{", "return", "sh_recog_treg_set_expr_reent_count", ">", "0", ";", "}", "</s>" ]

[ "Returns", "true", "when", "recog", "of", "a", "'treg_set_expr", "'", "is", "currently", "in", "progress", ".", "This", "can", "be", "used", "as", "a", "condition", "for", "insn/split", "patterns", "to", "allow", "certain", "T", "bit", "setting", "patters", "only", "to", "be", "matched", "as", "sub", "expressions", "of", "other", "patterns", "." ]

[ "sh", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon generate \\\"extract\\\" instructions\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon generate \\\"extract\\\" instructions\"" ]

[]

[ "<s>", "const", "char", "*", "output_plussi", "(", "rtx", "*", "operands", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "if", "(", "TARGET_H8300", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "return", "\"add.w\\t%f2,%f0\\n\\taddx\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "(", "n", "&", "0xffffff", ")", "==", "0", ")", "return", "\"add\\t%z2,%z0\"", ";", "if", "(", "(", "n", "&", "0xffff", ")", "==", "0", ")", "return", "\"add\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", ";", "if", "(", "(", "n", "&", "0xff", ")", "==", "0", ")", "return", "\"add\\t%x2,%x0\\n\\taddx\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", ";", "}", "return", "\"add\\t%w2,%w0\\n\\taddx\\t%x2,%x0\\n\\taddx\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", ";", "}", "else", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "register_operand", "(", "operands", "[", "1", "]", ",", "VOIDmode", ")", ")", "{", "HOST_WIDE_INT", "intval", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "1", "&&", "intval", "<=", "7", ")", ")", "return", "\"add.l\\t%S2,%S0\"", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "-", "7", "&&", "intval", "<=", "-", "1", ")", ")", "return", "\"sub.l\\t%G2,%S0\"", ";", "switch", "(", "(", "unsigned", "int", ")", "intval", "&", "0xffffffff", ")", "{", "case", "0x00000001", ":", "case", "0x00000002", ":", "case", "0x00000004", ":", "return", "\"adds\\t%2,%S0\"", ";", "case", "0xffffffff", ":", "case", "0xfffffffe", ":", "case", "0xfffffffc", ":", "return", "\"subs\\t%G2,%S0\"", ";", "case", "0x00010000", ":", "case", "0x00020000", ":", "operands", "[", "2", "]", "=", "GEN_INT", "(", "intval", ">>", "16", ")", ";", "return", "\"inc.w\\t%2,%e0\"", ";", "case", "0xffff0000", ":", "case", "0xfffe0000", ":", "operands", "[", "2", "]", "=", "GEN_INT", "(", "intval", ">>", "16", ")", ";", "return", "\"dec.w\\t%G2,%e0\"", ";", "}", "if", "(", "(", "intval", "&", "0xffff", ")", "==", "0", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "intval", ">>", "16", ")", ";", "return", "\"add.w\\t%2,%e0\"", ";", "}", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "return", "\"sub.l\\t%S2,%S0\"", ";", "}", "return", "\"add.l\\t%S2,%S0\"", ";", "}", "}", "</s>" ]

[ "Output", "an", "addition", "insn", "." ]

[ "h8300", "0", "2", "\"add.w\\t%f2,%f0\\n\\taddx\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", "2", "2", "0xffffff", "0", "\"add\\t%z2,%z0\"", "0xffff", "0", "\"add\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", "0xff", "0", "\"add\\t%x2,%x0\\n\\taddx\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", "\"add\\t%w2,%w0\\n\\taddx\\t%x2,%x0\\n\\taddx\\t%y2,%y0\\n\\taddx\\t%z2,%z0\"", "2", "1", "2", "1", "7", "\"add.l\\t%S2,%S0\"", "7", "1", "\"sub.l\\t%G2,%S0\"", "0xffffffff", "0x00000001", "0x00000002", "0x00000004", "\"adds\\t%2,%S0\"", "0xffffffff", "0xfffffffe", "0xfffffffc", "\"subs\\t%G2,%S0\"", "0x00010000", "0x00020000", "2", "16", "\"inc.w\\t%2,%e0\"", "0xffff0000", "0xfffe0000", "2", "16", "\"dec.w\\t%G2,%e0\"", "0xffff", "0", "2", "16", "\"add.w\\t%2,%e0\"", "2", "2", "0", "2", "2", "\"sub.l\\t%S2,%S0\"", "\"add.l\\t%S2,%S0\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "ARMHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"ARM hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "->", "isDebugValue", "(", ")", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "LastMI", "&&", "(", "MCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "!=", "ARMII", "::", "DomainGeneral", ")", "{", "MachineInstr", "*", "DefMI", "=", "LastMI", ";", "const", "MCInstrDesc", "&", "LastMCID", "=", "LastMI", "->", "getDesc", "(", ")", ";", "const", "TargetMachine", "&", "TM", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getTarget", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "LastMI", "->", "isBarrier", "(", ")", "&&", "!", "(", "TII", ".", "getSubtarget", "(", ")", ".", "isLikeA9", "(", ")", "&&", "(", "LastMI", "->", "mayLoad", "(", ")", "||", "LastMI", "->", "mayStore", "(", ")", ")", ")", "&&", "(", "LastMCID", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainGeneral", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "LastMI", ";", "if", "(", "I", "!=", "LastMI", "->", "getParent", "(", ")", "->", "begin", "(", ")", ")", "{", "I", "=", "std", "::", "prev", "(", "I", ")", ";", "DefMI", "=", "&", "*", "I", ";", "}", "}", "if", "(", "TII", ".", "isFpMLxInstruction", "(", "DefMI", "->", "getOpcode", "(", ")", ")", "&&", "(", "TII", ".", "canCauseFpMLxStall", "(", "MI", "->", "getOpcode", "(", ")", ")", "||", "hasRAWHazard", "(", "DefMI", ",", "MI", ",", "TII", ".", "getRegisterInfo", "(", ")", ")", ")", ")", "{", "if", "(", "FpMLxStalls", "==", "0", ")", "FpMLxStalls", "=", "4", ";", "return", "Hazard", ";", "}", "}", "}", "return", "ScoreboardHazardRecognizer", "::", "getHazardType", "(", "SU", ",", "Stalls", ")", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "ARM", "ARM", "0", "\"ARM hazards don't support scoreboard lookahead\"", "ARMII::DomainMask", "ARMII::DomainGeneral", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainGeneral", "0", "4" ]

[]

[ "<s>", "unsigned", "OR1KRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "OR1K", "::", "R2", ":", "OR1K", "::", "R1", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K::R2", "OR1K::R1" ]

[]

[ "<s>", "unsigned", "getNumberOfRegisters", "(", "bool", "Vector", ")", "const", "override", "{", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "16", ";", "return", "0", ";", "}", "if", "(", "ST", "->", "isThumb1Only", "(", ")", ")", "return", "8", ";", "return", "13", ";", "}", "</s>" ]

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

[ "ARM", "16", "0", "8", "13" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "unsigned", "Idx", ")", "const", "{", "unsigned", "SGPRLimit", "=", "getNumSGPRsAllowed", "(", "ST", ".", "getGeneration", "(", ")", ",", "ST", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "unsigned", "VGPRLimit", "=", "getNumVGPRsAllowed", "(", "ST", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "NumSubRegs", "=", "std", "::", "max", "(", "(", "int", ")", "(", "*", "I", ")", "->", "getSize", "(", ")", "/", "4", ",", "1", ")", ";", "unsigned", "Limit", ";", "if", "(", "isSGPRClass", "(", "*", "I", ")", ")", "{", "Limit", "=", "SGPRLimit", "/", "NumSubRegs", ";", "}", "else", "{", "Limit", "=", "VGPRLimit", "/", "NumSubRegs", ";", "}", "const", "int", "*", "Sets", "=", "getRegClassPressureSets", "(", "*", "I", ")", ";", "assert", "(", "Sets", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "Sets", "[", "i", "]", "!=", "-", "1", ";", "++", "i", ")", "{", "if", "(", "Sets", "[", "i", "]", "==", "(", "int", ")", "Idx", ")", "return", "Limit", ";", "}", "}", "return", "256", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "R600", "SI", "4", "1", "0", "1", "256" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "isFrameAddressTaken", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ";", "return", "HasFP", ";", "}", "</s>" ]

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

[ "ARC", "ARC" ]

[]

[ "<s>", "rtx", "frv_split_abs", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "dest", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "cc_reg", "=", "operands", "[", "2", "]", ";", "rtx", "cr_reg", "=", "operands", "[", "3", "]", ";", "rtx", "ret", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src", ",", "const0_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cr_reg", ",", "gen_rtx_fmt_ee", "(", "LT", ",", "CC_CCRmode", ",", "cc_reg", ",", "const0_rtx", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_NE", "(", "CC_CCRmode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_negsi2", "(", "dest", ",", "src", ")", ")", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src", ")", ")", "emit_insn", "(", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "gen_rtx_EQ", "(", "CC_CCRmode", ",", "cr_reg", ",", "const0_rtx", ")", ",", "gen_rtx_SET", "(", "dest", ",", "src", ")", ")", ")", ";", "ret", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Split", "an", "integer", "abs", "operation", "returning", "a", "SEQUENCE", "containing", "all", "of", "the", "insns", "." ]

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

[]

[ "<s>", "static", "rtx", "xtensa_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "fun", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "?", "SImode", ":", "mode", ",", "GP_RETURN_FIRST", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_LIBCALL_VALUE", "." ]

[ "xtensa" ]

[]