Datasets:

---

docz1105

/

ComBack

like 9

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

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

[ "X86", "5" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "AMDGPUOperand", "&", "Operand", "=", "(", "AMDGPUOperand", "&", ")", "Op", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_addr64", ":", "return", "Operand", ".", "isAddr64", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_gds", ":", "return", "Operand", ".", "isGDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_lds", ":", "return", "Operand", ".", "isLDS", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_glc", ":", "return", "Operand", ".", "isGLC", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_idxen", ":", "return", "Operand", ".", "isIdxen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_offen", ":", "return", "Operand", ".", "isOffen", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcB32", ":", "return", "Operand", ".", "isSSrcB32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SSrcF32", ":", "return", "Operand", ".", "isSSrcF32", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_SoppBrTarget", ":", "return", "Operand", ".", "isSoppBrTarget", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_VReg32OrOff", ":", "return", "Operand", ".", "isVReg32OrOff", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_InterpSlot", ":", "return", "Operand", ".", "isInterpSlot", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_Attr", ":", "return", "Operand", ".", "isInterpAttr", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "case", "MCK_AttrChan", ":", "return", "Operand", ".", "isAttrChan", "(", ")", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AMDGPUTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownOne", ".", "getBitWidth", "(", ")", ",", "0", ")", ";", "APInt", "KnownZero2", ";", "APInt", "KnownOne2", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "switch", "(", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ")", "{", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umax", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_imin", ":", "case", "AMDGPUIntrinsic", "::", "AMDGPU_umin", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "Op", ".", "getOperand", "(", "2", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "}", "case", "AMDGPUISD", "::", "SMAX", ":", "case", "AMDGPUISD", "::", "UMAX", ":", "case", "AMDGPUISD", "::", "SMIN", ":", "case", "AMDGPUISD", "::", "UMIN", ":", "computeKnownBitsForMinMax", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZero", ",", "KnownOne", ",", "DAG", ",", "Depth", ")", ";", "break", ";", "case", "AMDGPUISD", "::", "BFE_I32", ":", "case", "AMDGPUISD", "::", "BFE_U32", ":", "{", "ConstantSDNode", "*", "CWidth", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "if", "(", "!", "CWidth", ")", "return", ";", "unsigned", "BitWidth", "=", "32", ";", "uint32_t", "Width", "=", "CWidth", "->", "getZExtValue", "(", ")", "&", "0x1f", ";", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BFE_U32", ")", "KnownZero", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "Width", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "R600", "0", "ISD::INTRINSIC_WO_CHAIN", "0", "AMDGPUIntrinsic::AMDGPU_imax", "AMDGPUIntrinsic::AMDGPU_umax", "AMDGPUIntrinsic::AMDGPU_imin", "AMDGPUIntrinsic::AMDGPU_umin", "1", "2", "AMDGPUISD::SMAX", "AMDGPUISD::UMAX", "AMDGPUISD::SMIN", "AMDGPUISD::UMIN", "0", "1", "AMDGPUISD::BFE_I32", "AMDGPUISD::BFE_U32", "2", "32", "0x1f", "AMDGPUISD::BFE_U32" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "assert", "(", "0", "&&", "\"TLS not implemented for Sparc.\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerCONSTANTPOOL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CALL", ":", "return", "LowerCALL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RET", ":", "return", "LowerRET", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Sparc", "Sparc", "0", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "0", "\"TLS not implemented for Sparc.\"", "ISD::GlobalAddress", "ISD::ConstantPool", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::VASTART", "ISD::VAARG", "ISD::DYNAMIC_STACKALLOC", "ISD::CALL", "ISD::RET" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "report_fatal_error", "(", "\"emitEpilogue doesn't support framepointer-less functions\"", ")", ";", "}", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "MachineBasicBlock", "::", "iterator", "LastFrameDestroy", "=", "MBBI", ";", "std", "::", "advance", "(", "LastFrameDestroy", ",", "-", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"emitEpilogue doesn't support framepointer-less functions\"", "RISCV" ]

[]

[ "<s>", "static", "void", "cris_print_index", "(", "rtx", "index", ",", "FILE", "*", "file", ")", "{", "rtx", "inner", "=", "XEXP", "(", "index", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "index", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "index", ")", ">=", "0", ")", "putc", "(", "'+'", ",", "file", ")", ";", "if", "(", "REG_P", "(", "index", ")", ")", "fprintf", "(", "file", ",", "\"$%s.b\"", ",", "reg_names", "[", "REGNO", "(", "index", ")", "]", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "index", ")", ")", "cris_output_addr_const", "(", "file", ",", "index", ")", ";", "else", "if", "(", "GET_CODE", "(", "index", ")", "==", "MULT", ")", "{", "fprintf", "(", "file", ",", "\"$%s.\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "index", ",", "0", ")", ")", "]", ")", ";", "putc", "(", "INTVAL", "(", "XEXP", "(", "index", ",", "1", ")", ")", "==", "2", "?", "'w'", ":", "'d'", ",", "file", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "index", ")", "==", "SIGN_EXTEND", "&&", "GET_CODE", "(", "inner", ")", "==", "MEM", ")", "{", "rtx", "inner_inner", "=", "XEXP", "(", "inner", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "inner_inner", ")", "==", "POST_INC", ")", "{", "fprintf", "(", "file", ",", "\"[$%s+].\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "inner_inner", ",", "0", ")", ")", "]", ")", ";", "putc", "(", "GET_MODE", "(", "inner", ")", "==", "HImode", "?", "'w'", ":", "'b'", ",", "file", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"[$%s].\"", ",", "reg_names", "[", "REGNO", "(", "inner_inner", ")", "]", ")", ";", "putc", "(", "GET_MODE", "(", "inner", ")", "==", "HImode", "?", "'w'", ":", "'b'", ",", "file", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "index", ")", "==", "MEM", ")", "{", "if", "(", "GET_CODE", "(", "inner", ")", "==", "POST_INC", ")", "fprintf", "(", "file", ",", "\"[$%s+].d\"", ",", "reg_names", "[", "REGNO", "(", "XEXP", "(", "inner", ",", "0", ")", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"[$%s].d\"", ",", "reg_names", "[", "REGNO", "(", "inner", ")", "]", ")", ";", "}", "else", "cris_operand_lossage", "(", "\"unexpected index-type in cris_print_index\"", ",", "index", ")", ";", "}", "</s>" ]

[ "Print", "an", "index", "part", "of", "an", "address", "to", "file", "." ]

[ "cris", "0", "0", "\"$%s.b\"", "\"$%s.\"", "0", "1", "2", "0", "\"[$%s+].\"", "0", "\"[$%s].\"", "\"[$%s+].d\"", "0", "\"[$%s].d\"", "\"unexpected index-type in cris_print_index\"" ]

[]

[ "<s>", "static", "bool", "aarch64_pac_insn_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "INSN_P", "(", "x", ")", ")", "return", "false", ";", "subrtx_var_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_VAR", "(", "iter", ",", "array", ",", "PATTERN", "(", "x", ")", ",", "ALL", ")", "{", "rtx", "sub", "=", "*", "iter", ";", "if", "(", "sub", "&&", "GET_CODE", "(", "sub", ")", "==", "UNSPEC", ")", "{", "int", "unspec_val", "=", "XINT", "(", "sub", ",", "1", ")", ";", "switch", "(", "unspec_val", ")", "{", "case", "UNSPEC_PACIASP", ":", "case", "UNSPEC_PACIBSP", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Check", "if", "X", "(", "or", "any", "sub-rtx", "of", "X", ")", "is", "a", "PACIASP/PACIBSP", "instruction", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Control Flow Graph structurizer Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Control Flow Graph structurizer Pass\"" ]

[]

[ "<s>", "static", "int", "s390_issue_rate", "(", "void", ")", "{", "switch", "(", "s390_tune", ")", "{", "case", "PROCESSOR_2084_Z990", ":", "case", "PROCESSOR_2094_Z9_109", ":", "case", "PROCESSOR_2094_Z9_EC", ":", "case", "PROCESSOR_2817_Z196", ":", "return", "3", ";", "case", "PROCESSOR_2097_Z10", ":", "return", "2", ";", "case", "PROCESSOR_2064_Z900", ":", "case", "PROCESSOR_2827_ZEC12", ":", "case", "PROCESSOR_2964_Z13", ":", "case", "PROCESSOR_3906_Z14", ":", "case", "PROCESSOR_3931_Z16", ":", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "The", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "s390", "3", "2", "1" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", "&&", "AM", ".", "Scale", ")", "return", "false", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "Ty", "->", "isSized", "(", ")", ")", "{", "uint64_t", "NumBits", "=", "getDataLayout", "(", ")", "->", "getTypeSizeInBits", "(", "Ty", ")", ";", "NumBytes", "=", "NumBits", "/", "8", ";", "if", "(", "!", "isPowerOf2_64", "(", "NumBits", ")", ")", "NumBytes", "=", "0", ";", "}", "if", "(", "!", "AM", ".", "Scale", ")", "{", "int64_t", "Offset", "=", "AM", ".", "BaseOffs", ";", "if", "(", "Offset", ">=", "-", "(", "1LL", "<<", "9", ")", "&&", "Offset", "<=", "(", "1LL", "<<", "9", ")", "-", "1", ")", "return", "true", ";", "unsigned", "shift", "=", "Log2_64", "(", "NumBytes", ")", ";", "if", "(", "NumBytes", "&&", "Offset", ">", "0", "&&", "(", "Offset", "/", "NumBytes", ")", "<=", "(", "1LL", "<<", "12", ")", "-", "1", "&&", "(", "Offset", ">>", "shift", ")", "<<", "shift", "==", "Offset", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "!", "AM", ".", "Scale", "||", "AM", ".", "Scale", "==", "1", "||", "(", "AM", ".", "Scale", ">", "0", "&&", "(", "uint64_t", ")", "AM", ".", "Scale", "==", "NumBytes", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "8", "0", "1LL", "9", "1LL", "9", "1", "0", "1LL", "12", "1", "1", "0" ]

[]

[ "<s>", "static", "rtx", "sparc_function_incoming_arg", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "return", "sparc_function_arg_1", "(", "cum", ",", "mode", ",", "type", ",", "named", ",", "true", ")", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_FUNCTION_INCOMING_ARG", "target", "hook", "." ]

[ "sparc" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "BuildCFI", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "const", "MCCFIInstruction", "&", "CFIInst", ",", "MachineInstr", "::", "MIFlag", "Flag", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "CFIInst", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ".", "setMIFlag", "(", "Flag", ")", ";", "}", "</s>" ]

[ "Wraps", "up", "getting", "a", "CFI", "index", "and", "building", "a", "MachineInstr", "for", "it", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "compute_current_alignment", "(", "unsigned", "HOST_WIDE_INT", "base_align", ",", "unsigned", "HOST_WIDE_INT", "offset", ")", "{", "if", "(", "offset", "==", "0", ")", "return", "base_align", ";", "return", "min", "(", "base_align", ",", "offset", "&", "-", "offset", ")", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "of", "pointer+OFFSET", "where", "the", "original", "alignment", "of", "pointer", "was", "BASE_ALIGN", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "bool", "PPCTTIImpl", "::", "isHardwareLoopProfitable", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "AssumptionCache", "&", "AC", ",", "TargetLibraryInfo", "*", "LibInfo", ",", "HardwareLoopInfo", "&", "HWLoopInfo", ")", "{", "const", "PPCTargetMachine", "&", "TM", "=", "ST", "->", "getTargetMachine", "(", ")", ";", "TargetSchedModel", "SchedModel", ";", "SchedModel", ".", "init", "(", "ST", ")", ";", "unsigned", "ConstTripCount", "=", "SE", ".", "getSmallConstantTripCount", "(", "L", ")", ";", "if", "(", "ConstTripCount", "&&", "ConstTripCount", "<", "SmallCTRLoopThreshold", ")", "{", "SmallPtrSet", "<", "const", "Value", "*", ",", "32", ">", "EphValues", ";", "CodeMetrics", "::", "collectEphemeralValues", "(", "L", ",", "&", "AC", ",", "EphValues", ")", ";", "CodeMetrics", "Metrics", ";", "for", "(", "BasicBlock", "*", "BB", ":", "L", "->", "blocks", "(", ")", ")", "Metrics", ".", "analyzeBasicBlock", "(", "BB", ",", "*", "this", ",", "EphValues", ")", ";", "if", "(", "Metrics", ".", "NumInsts", "<=", "(", "6", "*", "SchedModel", ".", "getIssueWidth", "(", ")", ")", ")", "return", "false", ";", "}", "for", "(", "Loop", "::", "block_iterator", "I", "=", "L", "->", "block_begin", "(", ")", ",", "IE", "=", "L", "->", "block_end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "if", "(", "mightUseCTR", "(", "*", "I", ",", "LibInfo", ")", ")", "return", "false", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "for", "(", "auto", "&", "BB", ":", "ExitingBlocks", ")", "{", "Instruction", "*", "TI", "=", "BB", "->", "getTerminator", "(", ")", ";", "if", "(", "!", "TI", ")", "continue", ";", "if", "(", "BranchInst", "*", "BI", "=", "dyn_cast", "<", "BranchInst", ">", "(", "TI", ")", ")", "{", "uint64_t", "TrueWeight", "=", "0", ",", "FalseWeight", "=", "0", ";", "if", "(", "!", "BI", "->", "isConditional", "(", ")", "||", "!", "BI", "->", "extractProfMetadata", "(", "TrueWeight", ",", "FalseWeight", ")", ")", "continue", ";", "bool", "TrueIsExit", "=", "!", "L", "->", "contains", "(", "BI", "->", "getSuccessor", "(", "0", ")", ")", ";", "if", "(", "(", "TrueIsExit", "&&", "FalseWeight", "<", "TrueWeight", ")", "||", "(", "!", "TrueIsExit", "&&", "FalseWeight", ">", "TrueWeight", ")", ")", "return", "false", ";", "}", "}", "LLVMContext", "&", "C", "=", "L", "->", "getHeader", "(", ")", "->", "getContext", "(", ")", ";", "HWLoopInfo", ".", "CountType", "=", "TM", ".", "isPPC64", "(", ")", "?", "Type", "::", "getInt64Ty", "(", "C", ")", ":", "Type", "::", "getInt32Ty", "(", "C", ")", ";", "HWLoopInfo", ".", "LoopDecrement", "=", "ConstantInt", "::", "get", "(", "HWLoopInfo", ".", "CountType", ",", "1", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Query", "the", "target", "whether", "it", "would", "be", "profitable", "to", "convert", "the", "given", "loop", "into", "a", "hardware", "loop", "." ]

[ "PowerPC", "PPC", "PPC", "32", "6", "4", "0", "0", "0", "PPC", "1" ]

[]

[ "<s>", "static", "uint8_t", "name", "(", "struct", "InternalInstruction", "*", "insn", ",", "\\", "OperandType", "type", ",", "\\", "uint8_t", "index", ",", "\\", "uint8_t", "*", "valid", ")", "{", "\\", "*", "valid", "=", "1", ";", "\\", "switch", "(", "type", ")", "{", "\\", "default", ":", "\\", "debug", "(", "\"Unhandled register type\"", ")", ";", "\\", "*", "valid", "=", "0", ";", "\\", "return", "0", ";", "\\", "case", "TYPE_Rv", ":", "\\", "return", "base", "+", "index", ";", "\\", "case", "TYPE_R8", ":", "\\", "if", "(", "insn", "->", "rexPrefix", "&&", "\\", "index", ">=", "4", "&&", "index", "<=", "7", ")", "{", "\\", "return", "prefix", "##", "_SPL", "+", "(", "index", "-", "4", ")", ";", "\\", "}", "else", "{", "\\", "return", "prefix", "##", "_AL", "+", "index", ";", "\\", "}", "\\", "case", "TYPE_R16", ":", "\\", "return", "prefix", "##", "_AX", "+", "index", ";", "\\", "case", "TYPE_R32", ":", "\\", "return", "prefix", "##", "_EAX", "+", "index", ";", "\\", "case", "TYPE_R64", ":", "\\", "return", "prefix", "##", "_RAX", "+", "index", ";", "\\", "case", "TYPE_XMM512", ":", "\\", "return", "prefix", "##", "_ZMM0", "+", "index", ";", "\\", "case", "TYPE_XMM256", ":", "\\", "return", "prefix", "##", "_YMM0", "+", "index", ";", "\\", "case", "TYPE_XMM128", ":", "\\", "case", "TYPE_XMM64", ":", "\\", "case", "TYPE_XMM32", ":", "\\", "case", "TYPE_XMM", ":", "\\", "return", "prefix", "##", "_XMM0", "+", "index", ";", "\\", "case", "TYPE_VK1", ":", "\\", "case", "TYPE_VK8", ":", "\\", "case", "TYPE_VK16", ":", "\\", "return", "prefix", "##", "_K0", "+", "index", ";", "\\", "case", "TYPE_MM64", ":", "\\", "case", "TYPE_MM32", ":", "\\", "case", "TYPE_MM", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_MM0", "+", "index", ";", "\\", "case", "TYPE_SEGMENTREG", ":", "\\", "if", "(", "index", ">", "5", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_ES", "+", "index", ";", "\\", "case", "TYPE_DEBUGREG", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_DR0", "+", "index", ";", "\\", "case", "TYPE_CONTROLREG", ":", "\\", "if", "(", "index", ">", "8", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_CR0", "+", "index", ";", "\\", "}", "\\", "}", "</s>" ]

[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]

[ "X86", "1", "\"Unhandled register type\"", "0", "0", "4", "7", "4", "7", "0", "5", "0", "7", "0", "8", "0" ]

[]

[ "<s>", "const", "MCExpr", "*", "PPCTargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "const", "MachineFunction", "*", "MF", ",", "unsigned", "JTI", ",", "MCContext", "&", "Ctx", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", "||", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "TargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "MF", ",", "JTI", ",", "Ctx", ")", ";", "switch", "(", "getTargetMachine", "(", ")", ".", "getCodeModel", "(", ")", ")", "{", "case", "CodeModel", "::", "Small", ":", "case", "CodeModel", "::", "Medium", ":", "return", "TargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "MF", ",", "JTI", ",", "Ctx", ")", ";", "default", ":", "return", "MCSymbolRefExpr", "::", "create", "(", "MF", "->", "getPICBaseSymbol", "(", ")", ",", "Ctx", ")", ";", "}", "}", "</s>" ]

[ "This", "returns", "the", "relocation", "base", "for", "the", "given", "PIC", "jumptable", ",", "the", "same", "as", "getPICJumpTableRelocBase", ",", "but", "as", "an", "MCExpr", "." ]

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

[]

[ "<s>", "void", "loongarch_expand_prologue", "(", "void", ")", "{", "struct", "loongarch_frame_info", "*", "frame", "=", "&", "cfun", "->", "machine", "->", "frame", ";", "HOST_WIDE_INT", "size", "=", "frame", "->", "total_size", ";", "rtx", "insn", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "size", ";", "if", "(", "(", "frame", "->", "mask", "|", "frame", "->", "fmask", ")", "!=", "0", ")", "{", "HOST_WIDE_INT", "step1", "=", "MIN", "(", "size", ",", "loongarch_first_stack_step", "(", "frame", ")", ")", ";", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "step1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "size", "-=", "step1", ";", "loongarch_for_each_saved_reg", "(", "size", ",", "loongarch_save_reg", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "insn", "=", "gen_add3_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "frame", "->", "hard_frame_pointer_offset", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "loongarch_emit_stack_tie", "(", ")", ";", "}", "if", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "||", "flag_stack_clash_protection", ")", "{", "HOST_WIDE_INT", "first", "=", "get_stack_check_protect", "(", ")", ";", "if", "(", "frame", "->", "total_size", "==", "0", ")", "{", "dump_stack_clash_frame_info", "(", "NO_PROBE_NO_FRAME", ",", "false", ")", ";", "return", ";", "}", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "calls_alloca", ")", "{", "HOST_WIDE_INT", "interval", ";", "if", "(", "flag_stack_clash_protection", ")", "interval", "=", "STACK_CLASH_PROTECTION_GUARD_SIZE", ";", "else", "interval", "=", "PROBE_INTERVAL", ";", "if", "(", "size", ">", "interval", "&&", "size", ">", "first", ")", "loongarch_emit_probe_stack_range", "(", "first", ",", "size", "-", "first", ")", ";", "else", "loongarch_emit_probe_stack_range", "(", "first", ",", "size", ")", ";", "}", "else", "loongarch_emit_probe_stack_range", "(", "first", ",", "size", ")", ";", "if", "(", "size", ">", "0", ")", "{", "insn", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "size", ")", ";", "insn", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "insn", ")", ";", "loongarch_set_frame_expr", "(", "insn", ")", ";", "}", "return", ";", "}", "if", "(", "size", ">", "0", ")", "{", "if", "(", "IMM12_OPERAND", "(", "-", "size", ")", ")", "{", "insn", "=", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "emit_insn", "(", "insn", ")", ")", "=", "1", ";", "}", "else", "{", "loongarch_emit_move", "(", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ",", "GEN_INT", "(", "-", "size", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "LARCH_PROLOGUE_TEMP", "(", "Pmode", ")", ")", ")", ";", "insn", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "size", ")", ";", "insn", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "insn", ")", ";", "loongarch_set_frame_expr", "(", "insn", ")", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "static", "const", "uint32_t", "Nopcode", "=", "0x7f000000", ",", "ParseIn", "=", "0x00004000", ",", "ParseEnd", "=", "0x0000c000", ";", "while", "(", "Count", "%", "HEXAGON_INSTR_SIZE", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Alignment not a multiple of the instruction size:\"", "<<", "Count", "%", "HEXAGON_INSTR_SIZE", "<<", "\"/\"", "<<", "HEXAGON_INSTR_SIZE", "<<", "\"\\n\"", ")", ";", "--", "Count", ";", "OS", "<<", "'\\0'", ";", "}", "while", "(", "Count", ")", "{", "Count", "-=", "HEXAGON_INSTR_SIZE", ";", "uint32_t", "ParseBits", "=", "(", "Count", "%", "(", "MaxPacketSize", "*", "HEXAGON_INSTR_SIZE", ")", ")", "?", "ParseIn", ":", "ParseEnd", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Nopcode", "|", "ParseBits", ",", "Endian", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "0x7f000000", "0x00004000", "0x0000c000", "\"Alignment not a multiple of the instruction size:\"", "\"/\"", "\"\\n\"", "support::endian" ]

[]

[ "<s>", "SDValue", "R600TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "ShaderType", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", "->", "ShaderType", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "getOriginalFunctionArgs", "(", "DAG", ",", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ",", "Ins", ",", "LocalIns", ")", ";", "AnalyzeFormalArguments", "(", "CCInfo", ",", "LocalIns", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "EVT", "VT", "=", "Ins", "[", "i", "]", ".", "VT", ";", "EVT", "MemVT", "=", "LocalIns", "[", "i", "]", ".", "VT", ";", "if", "(", "ShaderType", "!=", "ShaderType", "::", "COMPUTE", ")", "{", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "&", "AMDGPU", "::", "R600_Reg128RegClass", ")", ";", "SDValue", "Register", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "VT", ")", ";", "InVals", ".", "push_back", "(", "Register", ")", ";", "continue", ";", "}", "PointerType", "*", "PtrTy", "=", "PointerType", "::", "get", "(", "VT", ".", "getTypeForEVT", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "AMDGPUAS", "::", "CONSTANT_BUFFER_0", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getExtLoad", "(", "ISD", "::", "SEXTLOAD", ",", "DL", ",", "VT", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "36", "+", "VA", ".", "getLocMemOffset", "(", ")", ",", "MVT", "::", "i32", ")", ",", "MachinePointerInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ")", ",", "MemVT", ",", "false", ",", "false", ",", "4", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "R600", "ISD::InputArg", "16", "ISD::InputArg", "8", "0", "AMDGPUAS::CONSTANT_BUFFER_0", "ISD::SEXTLOAD", "36", "MVT::i32", "4" ]

[]

[ "<s>", "static", "bool", "ix86_macro_fusion_pair_p", "(", "rtx_insn", "*", "condgen", ",", "rtx_insn", "*", "condjmp", ")", "{", "rtx", "src", ",", "dest", ";", "enum", "rtx_code", "ccode", ";", "rtx", "compare_set", "=", "NULL_RTX", ",", "test_if", ",", "cond", ";", "rtx", "alu_set", "=", "NULL_RTX", ",", "addr", "=", "NULL_RTX", ";", "if", "(", "!", "any_condjump_p", "(", "condjmp", ")", ")", "return", "false", ";", "if", "(", "get_attr_type", "(", "condgen", ")", "!=", "TYPE_TEST", "&&", "get_attr_type", "(", "condgen", ")", "!=", "TYPE_ICMP", "&&", "get_attr_type", "(", "condgen", ")", "!=", "TYPE_INCDEC", "&&", "get_attr_type", "(", "condgen", ")", "!=", "TYPE_ALU", ")", "return", "false", ";", "compare_set", "=", "single_set", "(", "condgen", ")", ";", "if", "(", "compare_set", "==", "NULL_RTX", "&&", "!", "TARGET_FUSE_ALU_AND_BRANCH", ")", "return", "false", ";", "if", "(", "compare_set", "==", "NULL_RTX", ")", "{", "int", "i", ";", "rtx", "pat", "=", "PATTERN", "(", "condgen", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", "==", "SET", ")", "{", "rtx", "set_src", "=", "SET_SRC", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", ";", "if", "(", "GET_CODE", "(", "set_src", ")", "==", "COMPARE", ")", "compare_set", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "else", "alu_set", "=", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ";", "}", "}", "if", "(", "compare_set", "==", "NULL_RTX", ")", "return", "false", ";", "src", "=", "SET_SRC", "(", "compare_set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "COMPARE", ")", "return", "false", ";", "if", "(", "(", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "||", "(", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", ")", "return", "false", ";", "if", "(", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ";", "else", "if", "(", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "XEXP", "(", "src", ",", "1", ")", ",", "0", ")", ";", "if", "(", "addr", ")", "{", "ix86_address", "parts", ";", "int", "ok", "=", "ix86_decompose_address", "(", "addr", ",", "&", "parts", ")", ";", "gcc_assert", "(", "ok", ")", ";", "if", "(", "rip_relative_addr_p", "(", "&", "parts", ")", ")", "return", "false", ";", "}", "test_if", "=", "SET_SRC", "(", "pc_set", "(", "condjmp", ")", ")", ";", "cond", "=", "XEXP", "(", "test_if", ",", "0", ")", ";", "ccode", "=", "GET_CODE", "(", "cond", ")", ";", "if", "(", "!", "TARGET_FUSE_CMP_AND_BRANCH_SOFLAGS", "&&", "(", "ccode", "==", "GE", "||", "ccode", "==", "GT", "||", "ccode", "==", "LE", "||", "ccode", "==", "LT", ")", ")", "return", "false", ";", "if", "(", "get_attr_type", "(", "condgen", ")", "==", "TYPE_TEST", "||", "get_attr_type", "(", "condgen", ")", "==", "TYPE_ICMP", ")", "return", "true", ";", "if", "(", "!", "TARGET_FUSE_ALU_AND_BRANCH", "||", "!", "alu_set", ")", "return", "false", ";", "dest", "=", "SET_DEST", "(", "alu_set", ")", ";", "if", "(", "MEM_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "get_attr_type", "(", "condgen", ")", "==", "TYPE_INCDEC", "&&", "(", "ccode", "==", "GEU", "||", "ccode", "==", "GTU", "||", "ccode", "==", "LEU", "||", "ccode", "==", "LTU", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "current", "microarchitecture", "support", "macro", "fusion", "for", "insn", "pair", "``", "CONDGEN", "+", "CONDJMP", "''", ".", "Refer", "to", "``", "Intel", "Architectures", "Optimization", "Reference", "Manual", "''", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "rtx", "s390_legitimize_cs_operand", "(", "rtx", "mem", ")", "{", "rtx", "tmp", ";", "if", "(", "!", "contains_symbol_ref_p", "(", "mem", ")", ")", "return", "mem", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "copy_rtx", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ")", ";", "return", "change_address", "(", "mem", ",", "VOIDmode", ",", "tmp", ")", ";", "}", "</s>" ]

[ "If", "MEM", "is", "not", "a", "legitimate", "compare-and-swap", "memory", "operand", ",", "return", "a", "new", "MEM", ",", "whose", "address", "is", "a", "pseudo", "containing", "the", "original", "MEM", "'s", "address", "." ]

[ "s390", "0" ]

[]

[ "<s>", "static", "void", "ia64_clear_sched_context", "(", "void", "*", "_sc", ")", "{", "ia64_sched_context_t", "sc", "=", "(", "ia64_sched_context_t", ")", "_sc", ";", "free", "(", "sc", "->", "prev_cycle_state", ")", ";", "sc", "->", "prev_cycle_state", "=", "NULL", ";", "}", "</s>" ]

[ "Clears", "the", "data", "in", "the", "_SC", "scheduling", "context", "." ]

[ "ia64" ]

[]

[ "<s>", "void", "LanaiInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Position", ",", "Register", "DestinationRegister", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RegisterClass", ",", "const", "TargetRegisterInfo", "*", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "Position", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "Position", "->", "getDebugLoc", "(", ")", ";", "}", "if", "(", "!", "Lanai", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RegisterClass", ")", ")", "{", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "Position", ",", "DL", ",", "get", "(", "Lanai", "::", "LDW_RI", ")", ",", "DestinationRegister", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "LPAC", "::", "ADD", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::GPRRegClass", "\"Can't load this register from stack slot\"", "Lanai::LDW_RI", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "MachineInstr", "&", "MIa", ",", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "assert", "(", "(", "MIa", ".", "mayLoad", "(", ")", "||", "MIa", ".", "mayStore", "(", ")", ")", "&&", "\"MIa must load from or modify a memory location\"", ")", ";", "assert", "(", "(", "MIb", ".", "mayLoad", "(", ")", "||", "MIb", ".", "mayStore", "(", ")", ")", "&&", "\"MIb must load from or modify a memory location\"", ")", ";", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "isDS", "(", "MIa", ")", ")", "{", "if", "(", "isDS", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "||", "isSegmentSpecificFLAT", "(", "MIb", ")", ";", "}", "if", "(", "isMUBUF", "(", "MIa", ")", "||", "isMTBUF", "(", "MIa", ")", ")", "{", "if", "(", "isMUBUF", "(", "MIb", ")", "||", "isMTBUF", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isSMRD", "(", "MIb", ")", ";", "}", "if", "(", "isSMRD", "(", "MIa", ")", ")", "{", "if", "(", "isSMRD", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "!", "isFLAT", "(", "MIb", ")", "&&", "!", "isMUBUF", "(", "MIa", ")", "&&", "!", "isMTBUF", "(", "MIa", ")", ";", "}", "if", "(", "isFLAT", "(", "MIa", ")", ")", "{", "if", "(", "isFLAT", "(", "MIb", ")", ")", "return", "checkInstOffsetsDoNotOverlap", "(", "MIa", ",", "MIb", ")", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "AMDGPU", "SI", "\"MIa must load from or modify a memory location\"", "\"MIb must load from or modify a memory location\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "bool", "Changed", "=", "false", ";", "if", "(", "EnableDelJmp", ")", "{", "MachineFunction", "::", "iterator", "FJ", "=", "F", ".", "begin", "(", ")", ";", "if", "(", "FJ", "!=", "F", ".", "end", "(", ")", ")", "FJ", "++", ";", "if", "(", "FJ", "==", "F", ".", "end", "(", ")", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FJ", "!=", "FE", ";", "++", "FI", ",", "++", "FJ", ")", "{", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ",", "*", "FJ", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Cpu0" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "ShouldShrinkFPConstant", "(", "EVT", "VT", ")", "const", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "return", "(", "ScalarVT", "!=", "MVT", "::", "f32", "&&", "ScalarVT", "!=", "MVT", "::", "f64", ")", ";", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "AMDGPU", "AMDGPU", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "StringRef", "getData", "(", ")", "const", "{", "return", "StringRef", "(", "Data", ".", "data", "(", ")", ",", "Data", ".", "size", "(", ")", ")", ";", "}", "</s>" ]

[ "Get", "the", "data", "pointed", "to", "by", "this", "extractor", "." ]

[ "HSAIL" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "static", "void", "init_ext_80387_constants", "(", "void", ")", "{", "static", "const", "char", "*", "cst", "[", "5", "]", "=", "{", "\"0.3010299956639811952256464283594894482\"", ",", "\"0.6931471805599453094286904741849753009\"", ",", "\"1.4426950408889634073876517827983434472\"", ",", "\"3.3219280948873623478083405569094566090\"", ",", "\"3.1415926535897932385128089594061862044\"", ",", "}", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "5", ";", "i", "++", ")", "{", "real_from_string", "(", "&", "ext_80387_constants_table", "[", "i", "]", ",", "cst", "[", "i", "]", ")", ";", "real_convert", "(", "&", "ext_80387_constants_table", "[", "i", "]", ",", "XFmode", ",", "&", "ext_80387_constants_table", "[", "i", "]", ")", ";", "}", "ext_80387_constants_init", "=", "1", ";", "}", "</s>" ]

[ "Initialize", "the", "table", "of", "extra", "80387", "mathematical", "constants", "." ]

[ "i386", "5", "\"0.3010299956639811952256464283594894482\"", "\"0.6931471805599453094286904741849753009\"", "\"1.4426950408889634073876517827983434472\"", "\"3.3219280948873623478083405569094566090\"", "\"3.1415926535897932385128089594061862044\"", "0", "5", "1" ]

[]

[ "<s>", "rtx", "mep_libcall_value", "(", "machine_mode", "mode", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "RETURN_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "LIBCALL_VALUE", ",", "using", "the", "same", "rules", "as", "mep_function_value", "." ]

[ "mep" ]

[]

[ "<s>", "int", "riscv_address_insns", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "might_split_p", ")", "{", "struct", "riscv_address_info", "addr", "=", "{", "}", ";", "int", "n", "=", "1", ";", "if", "(", "!", "riscv_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", ")", "{", "return", "3", ";", "}", "if", "(", "!", "riscv_v_ext_vector_mode_p", "(", "mode", ")", "&&", "mode", "!=", "BLKmode", "&&", "might_split_p", ")", "n", "+=", "(", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "addr", ".", "type", "==", "ADDRESS_LO_SUM", ")", "n", "+=", "riscv_symbol_insns", "(", "addr", ".", "symbol_type", ")", "-", "1", ";", "return", "n", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "load", "or", "store", "a", "value", "of", "mode", "MODE", "at", "address", "X", ".", "Return", "0", "if", "X", "is", "n't", "valid", "for", "MODE", ".", "Assume", "that", "multiword", "moves", "may", "need", "to", "be", "split", "into", "word", "moves", "if", "MIGHT_SPLIT_P", ",", "otherwise", "assume", "that", "a", "single", "load", "or", "store", "is", "enough", "." ]

[ "riscv", "1", "3", "1", "1" ]

[]

[ "<s>", "static", "SDValue", "buildRSRC", "(", "SelectionDAG", "*", "DAG", ",", "SDLoc", "DL", ",", "SDValue", "Ptr", ",", "uint32_t", "RsrcDword1", ",", "uint64_t", "RsrcDword2And3", ")", "{", "SDValue", "PtrLo", "=", "DAG", "->", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub0", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "SDValue", "PtrHi", "=", "DAG", "->", "getTargetExtractSubreg", "(", "AMDGPU", "::", "sub1", ",", "DL", ",", "MVT", "::", "i32", ",", "Ptr", ")", ";", "if", "(", "RsrcDword1", ")", "PtrHi", "=", "SDValue", "(", "DAG", "->", "getMachineNode", "(", "AMDGPU", "::", "S_OR_B32", ",", "DL", ",", "MVT", "::", "i32", ",", "PtrHi", ",", "DAG", "->", "getConstant", "(", "RsrcDword1", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "SDValue", "DataLo", "=", "DAG", "->", "getTargetConstant", "(", "RsrcDword2And3", "&", "APInt", "::", "getAllOnesValue", "(", "32", ")", ".", "getZExtValue", "(", ")", ",", "MVT", "::", "i32", ")", ";", "SDValue", "DataHi", "=", "DAG", "->", "getTargetConstant", "(", "RsrcDword2And3", ">>", "32", ",", "MVT", "::", "i32", ")", ";", "const", "SDValue", "Ops", "[", "]", "=", "{", "PtrLo", ",", "PtrHi", ",", "DataLo", ",", "DataHi", "}", ";", "return", "SDValue", "(", "DAG", "->", "getMachineNode", "(", "AMDGPU", "::", "SI_BUFFER_RSRC", ",", "DL", ",", "MVT", "::", "v4i32", ",", "Ops", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "a", "resource", "descriptor", "with", "the", "'Add", "TID", "'", "bit", "enabled", "The", "TID", "(", "Thread", "ID", ")", "is", "multiplied", "by", "the", "stride", "value", "(", "bits", "[", "61:48", "]", "of", "the", "resource", "descriptor", ")", "to", "create", "an", "offset", ",", "which", "is", "added", "to", "the", "resource", "pointer", "." ]

[ "R600", "MVT::i32", "MVT::i32", "MVT::i32", "MVT::i32", "0", "32", "MVT::i32", "32", "MVT::i32", "SI", "MVT::v4i32", "0" ]

[]

[ "<s>", "static", "bool", "cmse_func_args_or_return_in_stack", "(", "tree", "fndecl", ",", "tree", "name", ",", "tree", "fntype", ")", "{", "function_args_iterator", "args_iter", ";", "CUMULATIVE_ARGS", "args_so_far_v", ";", "cumulative_args_t", "args_so_far", ";", "bool", "first_param", "=", "true", ";", "tree", "arg_type", ",", "prev_arg_type", "=", "NULL_TREE", ",", "ret_type", ";", "arm_init_cumulative_args", "(", "&", "args_so_far_v", ",", "fntype", ",", "NULL_RTX", ",", "fndecl", ")", ";", "args_so_far", "=", "pack_cumulative_args", "(", "&", "args_so_far_v", ")", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "arg_type", ",", "args_iter", ")", "{", "rtx", "arg_rtx", ";", "machine_mode", "arg_mode", "=", "TYPE_MODE", "(", "arg_type", ")", ";", "prev_arg_type", "=", "arg_type", ";", "if", "(", "VOID_TYPE_P", "(", "arg_type", ")", ")", "continue", ";", "if", "(", "!", "first_param", ")", "arm_function_arg_advance", "(", "args_so_far", ",", "arg_mode", ",", "arg_type", ",", "true", ")", ";", "arg_rtx", "=", "arm_function_arg", "(", "args_so_far", ",", "arg_mode", ",", "arg_type", ",", "true", ")", ";", "if", "(", "!", "arg_rtx", "||", "arm_arg_partial_bytes", "(", "args_so_far", ",", "arg_mode", ",", "arg_type", ",", "true", ")", ")", "{", "error", "(", "\"%qE attribute not available to functions with arguments \"", "\"passed on the stack\"", ",", "name", ")", ";", "return", "true", ";", "}", "first_param", "=", "false", ";", "}", "if", "(", "prev_arg_type", "!=", "NULL_TREE", "&&", "!", "VOID_TYPE_P", "(", "prev_arg_type", ")", ")", "{", "error", "(", "\"%qE attribute not available to functions with variable number \"", "\"of arguments\"", ",", "name", ")", ";", "return", "true", ";", "}", "ret_type", "=", "TREE_TYPE", "(", "fntype", ")", ";", "if", "(", "arm_return_in_memory", "(", "ret_type", ",", "fntype", ")", ")", "{", "error", "(", "\"%qE attribute not available to functions that return value on \"", "\"the stack\"", ",", "name", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "returns", "true", "if", "a", "function", "with", "declaration", "FNDECL", "and", "type", "FNTYPE", "uses", "the", "stack", "to", "pass", "arguments", "or", "return", "variables", "and", "false", "otherwise", ".", "This", "is", "used", "for", "functions", "with", "the", "attributes", "'cmse_nonsecure_call", "'", "or", "'cmse_nonsecure_entry", "'", "and", "this", "function", "will", "issue", "diagnostic", "messages", "if", "the", "stack", "is", "used", ".", "NAME", "is", "the", "name", "of", "the", "attribute", "used", "." ]

[ "arm", "\"%qE attribute not available to functions with arguments \"", "\"passed on the stack\"", "\"%qE attribute not available to functions with variable number \"", "\"of arguments\"", "\"%qE attribute not available to functions that return value on \"", "\"the stack\"" ]

[]

[ "<s>", "bool", "PatmosFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STC", ".", "getInstrInfo", "(", ")", ";", "PatmosMachineFunctionInfo", "&", "PMFI", "=", "*", "MF", ".", "getInfo", "<", "PatmosMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Patmos", "::", "MOV", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RFP", ")", ";", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "unsigned", "tmpReg", "=", "Reg", ";", "if", "(", "Patmos", "::", "PRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "if", "(", "Reg", "==", "Patmos", "::", "S0", "&&", "PMFI", ".", "getS0SpillReg", "(", ")", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "Reg", ",", "PMFI", ".", "getS0SpillReg", "(", ")", ",", "true", ")", ";", "std", "::", "prev", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "continue", ";", "}", "if", "(", "Patmos", "::", "SRegsRegClass", ".", "contains", "(", "Reg", ")", ")", "tmpReg", "=", "Patmos", "::", "R9", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "tmpReg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "tmpReg", ",", "CSI", "[", "i", "-", "1", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "std", "::", "prev", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "tmpReg", "!=", "Reg", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "Reg", ",", "tmpReg", ",", "true", ")", ";", "std", "::", "prev", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "Patmos", "Patmos::MOV", "Patmos::RSP", "Patmos::RFP", "0", "1", "Patmos::PRegsRegClass", "Patmos::S0", "Patmos::SRegsRegClass", "Patmos::R9", "1" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_incoming_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "mode", "==", "VOIDmode", "||", "!", "named", ")", "return", "NULL_RTX", ";", "return", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "1", ",", "GEN_INT", "(", "cum", "->", "count", ")", ")", ",", "UNSPEC_ARG_REG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_INCOMING_ARG", "." ]

[ "nvptx", "1" ]

[]

[ "<s>", "bool", "MBlazeRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "NoFramePointerElim", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "bool", "function_instance", "::", "could_trap_p", "(", ")", "const", "{", "unsigned", "int", "flags", "=", "call_properties", "(", ")", ";", "if", "(", "flags", "&", "CP_RAISE_FP_EXCEPTIONS", ")", "return", "true", ";", "if", "(", "flags", "&", "(", "CP_READ_MEMORY", "|", "CP_WRITE_MEMORY", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "calls", "to", "the", "function", "could", "raise", "a", "signal", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "reg_unused_after", "(", "rtx_insn", "*", "insn", ",", "rtx", "reg", ")", "{", "return", "(", "dead_or_set_p", "(", "insn", ",", "reg", ")", "||", "(", "REG_P", "(", "reg", ")", "&&", "_reg_unused_after", "(", "insn", ",", "reg", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REG", "is", "not", "used", "after", "INSN", ".", "We", "assume", "REG", "is", "a", "reload", "reg", ",", "and", "therefore", "does", "not", "live", "past", "labels", "or", "calls", "or", "jumps", "." ]

[ "avr" ]

[]

[ "<s>", "static", "int", "first_altivec_reg_to_save", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_ALTIVEC_ABI", ")", "return", "LAST_ALTIVEC_REGNO", "+", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "crtl", "->", "calls_eh_return", "&&", "!", "TARGET_ALTIVEC", ")", "return", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "if", "(", "save_reg_p", "(", "i", ")", ")", "break", ";", "return", "i", ";", "}", "</s>" ]

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

[ "rs6000", "1", "20", "20" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_scalar_move_insn", "(", "insn_code", "icode", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "exp", ")", ")", ";", "int", "arg_offset", "=", "0", ";", "add_scalar_move_mask_operand", "(", "mask_mode", "(", ")", ")", ";", "if", "(", "use_real_merge_p", "(", "pred", ")", ")", "add_input_operand", "(", "arg_offset", "++", ")", ";", "else", "add_vundef_operand", "(", "mode", ")", ";", "for", "(", "int", "argno", "=", "arg_offset", ";", "argno", "<", "call_expr_nargs", "(", "exp", ")", ";", "argno", "++", ")", "add_input_operand", "(", "argno", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_tail_policy_for_pred", "(", "pred", ")", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_mask_policy_for_pred", "(", "pred", ")", ")", ";", "add_input_operand", "(", "Pmode", ",", "get_avl_type_rtx", "(", "avl_type", "::", "NONVLMAX", ")", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Implement", "the", "call", "using", "instruction", "ICODE", ",", "with", "a", "1:1", "mapping", "between", "arguments", "and", "input", "operands", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "virtual", "bool", "addPreEmitPass", "(", ")", "{", "if", "(", "!", "getPatmosSubtarget", "(", ")", ".", "usePatmosPostRAScheduler", "(", "getOptLevel", "(", ")", ")", ")", "{", "addPass", "(", "createPatmosDelaySlotFillerPass", "(", "getPatmosTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ")", ";", "}", "if", "(", "getPatmosSubtarget", "(", ")", ".", "hasMethodCache", "(", ")", ")", "{", "addPass", "(", "createPatmosFunctionSplitterPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "}", "addPass", "(", "createPatmosDelaySlotKillerPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosEnsureAlignmentPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createPatmosBypassFromPMLPass", "(", "getPatmosTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos", "Patmos" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Machine Code Emitter\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Machine Code Emitter\"" ]

[]

[ "<s>", "void", "OutgoingValueHandler", "::", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ValVReg", ")", ";", "MIB", ".", "addUse", "(", "PhysReg", ",", "RegState", "::", "Implicit", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "Mips" ]

[]

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

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "static", "void", "ultrasparc_sched_init", "(", ")", "{", "memset", "(", "(", "char", "*", ")", "ultra_pipe_hist", ",", "0", ",", "sizeof", "ultra_pipe_hist", ")", ";", "ultra_cur_hist", "=", "0", ";", "ultra_cycles_elapsed", "=", "0", ";", "ultra_pipe", ".", "free_slot_mask", "=", "0xf", ";", "}", "</s>" ]

[ "Init", "our", "data", "structures", "for", "this", "current", "block", "." ]

[ "sparc", "0", "0", "0", "0xf" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isAAPCS_ABI", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARMTargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getTargetData", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "static", "void", "ix86_avoid_jump_mispredicts", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "start", "=", "get_insns", "(", ")", ";", "int", "nbytes", "=", "0", ",", "njumps", "=", "0", ";", "bool", "isjump", "=", "false", ";", "for", "(", "insn", "=", "start", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "int", "min_size", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "{", "int", "align", "=", "label_to_alignment", "(", "insn", ")", ";", "int", "max_skip", "=", "label_to_max_skip", "(", "insn", ")", ";", "if", "(", "max_skip", ">", "15", ")", "max_skip", "=", "15", ";", "if", "(", "align", "<=", "0", "||", "(", "align", "<=", "3", "&&", "max_skip", "!=", "(", "1", "<<", "align", ")", "-", "1", ")", ")", "max_skip", "=", "0", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Label %i with max_skip %i\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "max_skip", ")", ";", "if", "(", "max_skip", ")", "{", "while", "(", "nbytes", "+", "max_skip", ">=", "16", ")", "{", "start", "=", "NEXT_INSN", "(", "start", ")", ";", "if", "(", "(", "JUMP_P", "(", "start", ")", "&&", "asm_noperands", "(", "PATTERN", "(", "start", ")", ")", "<", "0", ")", "||", "CALL_P", "(", "start", ")", ")", "njumps", "--", ",", "isjump", "=", "true", ";", "else", "isjump", "=", "false", ";", "nbytes", "-=", "ix86_min_insn_size", "(", "start", ")", ";", "}", "}", "continue", ";", "}", "min_size", "=", "ix86_min_insn_size", "(", "insn", ")", ";", "nbytes", "+=", "min_size", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Insn %i estimated to %i bytes\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "min_size", ")", ";", "if", "(", "(", "JUMP_P", "(", "insn", ")", "&&", "asm_noperands", "(", "PATTERN", "(", "insn", ")", ")", "<", "0", ")", "||", "CALL_P", "(", "insn", ")", ")", "njumps", "++", ";", "else", "continue", ";", "while", "(", "njumps", ">", "3", ")", "{", "start", "=", "NEXT_INSN", "(", "start", ")", ";", "if", "(", "(", "JUMP_P", "(", "start", ")", "&&", "asm_noperands", "(", "PATTERN", "(", "start", ")", ")", "<", "0", ")", "||", "CALL_P", "(", "start", ")", ")", "njumps", "--", ",", "isjump", "=", "true", ";", "else", "isjump", "=", "false", ";", "nbytes", "-=", "ix86_min_insn_size", "(", "start", ")", ";", "}", "gcc_assert", "(", "njumps", ">=", "0", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Interval %i to %i has %i bytes\\n\"", ",", "INSN_UID", "(", "start", ")", ",", "INSN_UID", "(", "insn", ")", ",", "nbytes", ")", ";", "if", "(", "njumps", "==", "3", "&&", "isjump", "&&", "nbytes", "<", "16", ")", "{", "int", "padsize", "=", "15", "-", "nbytes", "+", "ix86_min_insn_size", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Padding insn %i by %i bytes!\\n\"", ",", "INSN_UID", "(", "insn", ")", ",", "padsize", ")", ";", "emit_insn_before", "(", "gen_pad", "(", "GEN_INT", "(", "padsize", ")", ")", ",", "insn", ")", ";", "}", "}", "}", "</s>" ]

[ "AMD", "K8", "core", "mispredicts", "jumps", "when", "there", "are", "more", "than", "3", "jumps", "in", "16", "byte", "window", "." ]

[ "i386", "0", "0", "15", "15", "0", "3", "1", "1", "0", "\"Label %i with max_skip %i\\n\"", "16", "0", "\"Insn %i estimated to %i bytes\\n\"", "0", "3", "0", "0", "\"Interval %i to %i has %i bytes\\n\"", "3", "16", "15", "\"Padding insn %i by %i bytes!\\n\"" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", "->", "estimateStackSize", "(", "MF", ")", ":", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "PPCRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getLinkageSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ",", "Subtarget", ".", "isELFv2ABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "PM", "->", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "printAndVerify", "(", "\"After ARM load / store optimizer\"", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "hasNEON", "(", ")", ")", "PM", "->", "add", "(", "createExecutionDependencyFixPass", "(", "&", "ARM", "::", "DPRRegClass", ")", ")", ";", "}", "PM", "->", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "addPass", "(", "IfConverterID", ")", ";", "}", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "PM", "->", "add", "(", "createThumb2ITBlockPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\"After ARM load / store optimizer\"", "ARM", "ARM::DPRRegClass", "ARM", "ARM", "ARM" ]

[]

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

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

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

[]

[ "<s>", "static", "rtx", "crx_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "CRX_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>" ]

[ "Implements", "hook", "TARGET_STRUCT_VALUE_RTX", "." ]

[ "crx" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "enableShrinkWrapping", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "(", "MF", ".", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", "||", "hasFP", "(", "MF", ")", ")", "&&", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "!=", "CallingConv", "::", "HiPE", "&&", "!", "MF", ".", "shouldSplitStack", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "will", "correctly", "handle", "shrink", "wrapping", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "X86DiscriminateMemOps", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "EnableDiscriminateMemops", ")", "return", "false", ";", "DISubprogram", "*", "FDI", "=", "MF", ".", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "if", "(", "!", "FDI", "||", "!", "FDI", "->", "getUnit", "(", ")", "->", "getDebugInfoForProfiling", "(", ")", ")", "return", "false", ";", "const", "DILocation", "*", "ReferenceDI", "=", "DILocation", "::", "get", "(", "FDI", "->", "getContext", "(", ")", ",", "FDI", "->", "getLine", "(", ")", ",", "0", ",", "FDI", ")", ";", "assert", "(", "ReferenceDI", "&&", "\"ReferenceDI should not be nullptr\"", ")", ";", "DenseMap", "<", "Location", ",", "unsigned", ">", "MemOpDiscriminators", ";", "MemOpDiscriminators", "[", "diToLocation", "(", "ReferenceDI", ")", "]", "=", "0", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "const", "auto", "&", "DI", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DI", ")", "continue", ";", "Location", "Loc", "=", "diToLocation", "(", "DI", ")", ";", "MemOpDiscriminators", "[", "Loc", "]", "=", "std", "::", "max", "(", "MemOpDiscriminators", "[", "Loc", "]", ",", "DI", "->", "getBaseDiscriminator", "(", ")", ")", ";", "}", "}", "DenseMap", "<", "Location", ",", "DenseSet", "<", "unsigned", ">>", "Seen", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "X86II", "::", "getMemoryOperandNo", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ")", "<", "0", ")", "continue", ";", "const", "DILocation", "*", "DI", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DI", ")", "{", "DI", "=", "ReferenceDI", ";", "}", "Location", "L", "=", "diToLocation", "(", "DI", ")", ";", "DenseSet", "<", "unsigned", ">", "&", "Set", "=", "Seen", "[", "L", "]", ";", "const", "std", "::", "pair", "<", "DenseSet", "<", "unsigned", ">", "::", "iterator", ",", "bool", ">", "TryInsert", "=", "Set", ".", "insert", "(", "DI", "->", "getBaseDiscriminator", "(", ")", ")", ";", "if", "(", "!", "TryInsert", ".", "second", ")", "{", "unsigned", "BF", ",", "DF", ",", "CI", "=", "0", ";", "DILocation", "::", "decodeDiscriminator", "(", "DI", "->", "getDiscriminator", "(", ")", ",", "BF", ",", "DF", ",", "CI", ")", ";", "Optional", "<", "unsigned", ">", "EncodedDiscriminator", "=", "DILocation", "::", "encodeDiscriminator", "(", "MemOpDiscriminators", "[", "L", "]", "+", "1", ",", "DF", ",", "CI", ")", ";", "if", "(", "!", "EncodedDiscriminator", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unable to create a unique discriminator \"", "\"for instruction with memory operand in: \"", "<<", "DI", "->", "getFilename", "(", ")", "<<", "\" Line: \"", "<<", "DI", "->", "getLine", "(", ")", "<<", "\" Column: \"", "<<", "DI", "->", "getColumn", "(", ")", "<<", "\". This is likely due to a large macro expansion. \\n\"", ")", ";", "continue", ";", "}", "++", "MemOpDiscriminators", "[", "L", "]", ";", "DI", "=", "DI", "->", "cloneWithDiscriminator", "(", "EncodedDiscriminator", ".", "getValue", "(", ")", ")", ";", "assert", "(", "DI", "&&", "\"DI should not be nullptr\"", ")", ";", "updateDebugInfo", "(", "&", "MI", ",", "DI", ")", ";", "Changed", "=", "true", ";", "std", "::", "pair", "<", "DenseSet", "<", "unsigned", ">", "::", "iterator", ",", "bool", ">", "MustInsert", "=", "Set", ".", "insert", "(", "DI", "->", "getBaseDiscriminator", "(", ")", ")", ";", "(", "void", ")", "MustInsert", ";", "assert", "(", "MustInsert", ".", "second", "&&", "\"New discriminator shouldn't be present in set\"", ")", ";", "}", "ReferenceDI", "=", "DI", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"ReferenceDI should not be nullptr\"", "0", "X86II::getMemoryOperandNo", "0", "0", "1", "\"Unable to create a unique discriminator \"", "\"for instruction with memory operand in: \"", "\" Line: \"", "\" Column: \"", "\". This is likely due to a large macro expansion. \\n\"", "\"DI should not be nullptr\"", "\"New discriminator shouldn't be present in set\"" ]

[]

[ "<s>", "bool", "AMDGPULowerIntrinsics", "::", "makeLIDRangeMetadata", "(", "Function", "&", "F", ")", "const", "{", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "U", ":", "F", ".", "users", "(", ")", ")", "{", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "U", ")", ";", "if", "(", "!", "CI", ")", "continue", ";", "Changed", "|=", "AMDGPUSubtarget", "::", "get", "(", "TM", ",", "F", ")", ".", "makeLIDRangeMetadata", "(", "CI", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Creates", "value", "range", "metadata", "on", "an", "workitemid", ".", "*", "intrinsic", "call", "or", "load", "." ]

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

[]

[ "<s>", "rtx", "nds32_expand_load_multiple", "(", "int", "base_regno", ",", "int", "count", ",", "rtx", "base_addr", ",", "rtx", "basemem", ",", "bool", "update_base_reg_p", ",", "rtx", "*", "update_base_reg", ")", "{", "int", "par_index", ";", "int", "offset", ";", "int", "start_idx", ";", "rtx", "result", ";", "rtx", "new_addr", ",", "mem", ",", "reg", ";", "if", "(", "count", "==", "1", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "base_regno", ")", ";", "if", "(", "update_base_reg_p", ")", "{", "*", "update_base_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "return", "gen_unaligned_load_update_base_w", "(", "*", "update_base_reg", ",", "reg", ",", "base_addr", ")", ";", "}", "else", "return", "gen_unaligned_load_w", "(", "reg", ",", "gen_rtx_MEM", "(", "SImode", ",", "base_addr", ")", ")", ";", "}", "if", "(", "update_base_reg_p", ")", "{", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", "+", "1", ")", ")", ";", "start_idx", "=", "1", ";", "}", "else", "{", "result", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "count", ")", ")", ";", "start_idx", "=", "0", ";", "}", "if", "(", "update_base_reg_p", ")", "{", "offset", "=", "count", "*", "4", ";", "new_addr", "=", "plus_constant", "(", "Pmode", ",", "base_addr", ",", "offset", ")", ";", "*", "update_base_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "XVECEXP", "(", "result", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "*", "update_base_reg", ",", "new_addr", ")", ";", "}", "for", "(", "par_index", "=", "0", ";", "par_index", "<", "count", ";", "par_index", "++", ")", "{", "offset", "=", "par_index", "*", "4", ";", "new_addr", "=", "plus_constant", "(", "Pmode", ",", "base_addr", ",", "offset", ")", ";", "mem", "=", "adjust_automodify_address_nv", "(", "basemem", ",", "SImode", ",", "new_addr", ",", "offset", ")", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "base_regno", "+", "par_index", ")", ";", "XVECEXP", "(", "result", ",", "0", ",", "(", "par_index", "+", "start_idx", ")", ")", "=", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Functions", "to", "expand", "load_multiple", "and", "store_multiple", ".", "They", "are", "auxiliary", "extern", "functions", "to", "help", "create", "rtx", "template", ".", "Check", "nds32-multiple.md", "file", "for", "the", "patterns", "." ]

[ "nds32", "1", "1", "1", "0", "4", "0", "0", "0", "4", "0" ]

[]

[ "<s>", "static", "inline", "bool", "is_naked_func", "(", "const_tree", "decl", ")", "{", "return", "has_func_attr", "(", "decl", ",", "\"naked\"", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "naked", "''", "attribute", "." ]

[ "rx", "\"naked\"" ]

[]

[ "<s>", "static", "std", "::", "string", "getGraphName", "(", "const", "agraph", "&", "G", ")", "{", "return", "G", ".", "MF", "->", "getFunction", "(", ")", ".", "getName", "(", ")", ".", "str", "(", ")", ";", "}", "</s>" ]

[ "Generate", "a", "title", "for", "the", "graph", "in", "DOT", "format", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "int", "mips_multipass_dfa_lookahead", "(", "void", ")", "{", "if", "(", "mips_tune", "==", "PROCESSOR_SB1", ")", "return", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD", ".", "This", "should", "be", "as", "wide", "as", "the", "scheduling", "freedom", "in", "the", "DFA", "." ]

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "VFMADDPDr231r", ":", "case", "X86", "::", "VFMADDPSr231r", ":", "case", "X86", "::", "VFMADDSDr231r", ":", "case", "X86", "::", "VFMADDSSr231r", ":", "case", "X86", "::", "VFMSUBPDr231r", ":", "case", "X86", "::", "VFMSUBPSr231r", ":", "case", "X86", "::", "VFMSUBSDr231r", ":", "case", "X86", "::", "VFMSUBSSr231r", ":", "case", "X86", "::", "VFNMADDPDr231r", ":", "case", "X86", "::", "VFNMADDPSr231r", ":", "case", "X86", "::", "VFNMADDSDr231r", ":", "case", "X86", "::", "VFNMADDSSr231r", ":", "case", "X86", "::", "VFNMSUBPDr231r", ":", "case", "X86", "::", "VFNMSUBPSr231r", ":", "case", "X86", "::", "VFNMSUBSDr231r", ":", "case", "X86", "::", "VFNMSUBSSr231r", ":", "case", "X86", "::", "VFMADDPDr231rY", ":", "case", "X86", "::", "VFMADDPSr231rY", ":", "case", "X86", "::", "VFMSUBPDr231rY", ":", "case", "X86", "::", "VFMSUBPSr231rY", ":", "case", "X86", "::", "VFNMADDPDr231rY", ":", "case", "X86", "::", "VFNMADDPSr231rY", ":", "case", "X86", "::", "VFNMSUBPDr231rY", ":", "case", "X86", "::", "VFNMSUBPSr231rY", ":", "SrcOpIdx1", "=", "2", ";", "SrcOpIdx2", "=", "3", ";", "return", "true", ";", "default", ":", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "X86", "X86", "X86::VFMADDPDr231r", "X86::VFMADDPSr231r", "X86::VFMADDSDr231r", "X86::VFMADDSSr231r", "X86::VFMSUBPDr231r", "X86::VFMSUBPSr231r", "X86::VFMSUBSDr231r", "X86::VFMSUBSSr231r", "X86::VFNMADDPDr231r", "X86::VFNMADDPSr231r", "X86::VFNMADDSDr231r", "X86::VFNMADDSSr231r", "X86::VFNMSUBPDr231r", "X86::VFNMSUBPSr231r", "X86::VFNMSUBSDr231r", "X86::VFNMSUBSSr231r", "X86::VFMADDPDr231rY", "X86::VFMADDPSr231rY", "X86::VFMSUBPDr231rY", "X86::VFMSUBPSr231rY", "X86::VFNMADDPDr231rY", "X86::VFNMADDPSr231rY", "X86::VFNMSUBPDr231rY", "X86::VFNMSUBPSr231rY", "2", "3" ]

[]

[ "<s>", "void", "aarch64_split_simd_move", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src", ")", ";", "machine_mode", "dst_mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "dst_mode", ")", ")", ";", "if", "(", "REG_P", "(", "dst", ")", "&&", "REG_P", "(", "src", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "src_mode", ")", ")", ";", "switch", "(", "src_mode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_split_simd_movv16qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_split_simd_movv8hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_split_simd_movv4si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_split_simd_movv2di", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_split_simd_movv4sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_split_simd_movv2df", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "src", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Split", "a", "complex", "SIMD", "move", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "TGSISubtarget", ">", "(", ")", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI" ]

[]

[ "<s>", "bool", "riscv_v_ext_vector_mode_p", "(", "machine_mode", "mode", ")", "{", "case", "MODE", "##", "mode", ":", "\\", "return", "REQUIREMENT", ";", "switch", "(", "mode", ")", "{", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "mode", "is", "the", "RVV", "enabled", "mode", ".", "For", "example", ":", "'VNx1DI", "'", "mode", "is", "disabled", "if", "MIN_VLEN", "==", "32", ".", "'VNx1SI", "'", "mode", "is", "enabled", "if", "MIN_VLEN", "==", "32", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "const", "char", "*", "detect_processor_aix", "(", "void", ")", "{", "switch", "(", "_system_configuration", ".", "implementation", ")", "{", "case", "0x0008", ":", "return", "\"601\"", ";", "case", "0x0020", ":", "return", "\"603\"", ";", "case", "0x0010", ":", "return", "\"604\"", ";", "case", "0x0040", ":", "return", "\"620\"", ";", "case", "0x0080", ":", "return", "\"630\"", ";", "case", "0x0100", ":", "case", "0x0200", ":", "case", "0x0400", ":", "return", "\"rs64\"", ";", "case", "0x0800", ":", "return", "\"power4\"", ";", "case", "0x2000", ":", "if", "(", "_system_configuration", ".", "version", "==", "0x0F0000", ")", "return", "\"power5\"", ";", "else", "return", "\"power5+\"", ";", "case", "0x4000", ":", "return", "\"power6\"", ";", "case", "0x8000", ":", "return", "\"power7\"", ";", "case", "0x10000", ":", "return", "\"power8\"", ";", "default", ":", "return", "\"powerpc\"", ";", "}", "}", "</s>" ]

[ "Returns", "the", "processor", "implementation", "on", "AIX", "." ]

[ "rs6000", "0x0008", "\"601\"", "0x0020", "\"603\"", "0x0010", "\"604\"", "0x0040", "\"620\"", "0x0080", "\"630\"", "0x0100", "0x0200", "0x0400", "\"rs64\"", "0x0800", "\"power4\"", "0x2000", "0x0F0000", "\"power5\"", "\"power5+\"", "0x4000", "\"power6\"", "0x8000", "\"power7\"", "0x10000", "\"power8\"", "\"powerpc\"" ]

[]

[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "return", "std", "::", "string", "(", "\"E-p:32:32:32-i64:64:64-f64:64:64-f128:64:64-n32\"", ")", ";", "}", "</s>" ]

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

[ "TOY", "\"E-p:32:32:32-i64:64:64-f64:64:64-f128:64:64-n32\"" ]

[]

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

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

[ "rs6000" ]

[]

[ "<s>", "inline", "machine_mode", "function_expander", "::", "index_mode", "(", "void", ")", "const", "{", "return", "TYPE_MODE", "(", "op_info", "->", "args", "[", "1", "]", ".", "get_tree_type", "(", "type", ".", "index", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "machine_mode", "of", "the", "corresponding", "index", "type", "." ]

[ "riscv", "1" ]

[]

[ "<s>", "static", "const", "char", "*", "aarch64_mangle_type", "(", "const_tree", "type", ")", "{", "if", "(", "lang_hooks", ".", "types_compatible_p", "(", "CONST_CAST_TREE", "(", "type", ")", ",", "va_list_type", ")", ")", "return", "\"St9__va_list\"", ";", "if", "(", "TYPE_NAME", "(", "type", ")", "!=", "NULL", ")", "return", "aarch64_mangle_builtin_type", "(", "type", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MANGLE_TYPE", "." ]

[ "aarch64", "\"St9__va_list\"" ]

[]

[ "<s>", "char", "*", "construct_save_jarl", "(", "rtx", "op", ")", "{", "int", "count", "=", "XVECLEN", "(", "op", ",", "0", ")", ";", "int", "stack_bytes", ";", "unsigned", "long", "int", "mask", ";", "unsigned", "long", "int", "first", ";", "unsigned", "long", "int", "last", ";", "int", "i", ";", "static", "char", "buff", "[", "100", "]", ";", "if", "(", "count", "<=", "2", ")", "{", "error", "(", "\"bogus JARL construction: %d\\n\"", ",", "count", ")", ";", "return", "NULL", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ")", "==", "PLUS", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "0", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "stack_bytes", "=", "INTVAL", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "op", ",", "0", ",", "0", ")", ")", ",", "1", ")", ")", ";", "stack_bytes", "+=", "(", "count", "-", "(", "TARGET_LONG_CALLS", "?", "3", ":", "2", ")", ")", "*", "4", ";", "if", "(", "stack_bytes", "!=", "0", "&&", "stack_bytes", "!=", "-", "16", ")", "{", "error", "(", "\"bad amount of stack space removal: %d\"", ",", "stack_bytes", ")", ";", "return", "NULL", ";", "}", "mask", "=", "0", ";", "for", "(", "i", "=", "1", ";", "i", "<", "count", "-", "(", "TARGET_LONG_CALLS", "?", "2", ":", "1", ")", ";", "i", "++", ")", "{", "rtx", "vector_element", "=", "XVECEXP", "(", "op", ",", "0", ",", "i", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "vector_element", ")", "==", "SET", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "SET_SRC", "(", "vector_element", ")", ")", "==", "REG", ")", ";", "gcc_assert", "(", "register_is_ok_for_epilogue", "(", "SET_SRC", "(", "vector_element", ")", ",", "SImode", ")", ")", ";", "mask", "|=", "1", "<<", "REGNO", "(", "SET_SRC", "(", "vector_element", ")", ")", ";", "}", "for", "(", "first", "=", "0", ";", "first", "<", "32", ";", "first", "++", ")", "{", "if", "(", "mask", "&", "(", "1", "<<", "first", ")", ")", "break", ";", "}", "gcc_assert", "(", "first", "<", "32", ")", ";", "if", "(", "mask", "&", "(", "1", "<<", "LINK_POINTER_REGNUM", ")", ")", "{", "gcc_assert", "(", "stack_bytes", "==", "-", "16", ")", ";", "last", "=", "LINK_POINTER_REGNUM", ";", "}", "else", "{", "gcc_assert", "(", "!", "stack_bytes", ")", ";", "gcc_assert", "(", "mask", "&", "(", "1", "<<", "29", ")", ")", ";", "last", "=", "29", ";", "}", "if", "(", "TARGET_LONG_CALLS", ")", "{", "char", "name", "[", "40", "]", ";", "if", "(", "first", "==", "last", ")", "sprintf", "(", "name", ",", "\"__save_%s\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "name", ",", "\"__save_%s_%s\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "sprintf", "(", "buff", ",", "\"movhi hi(%s), r0, r11\\n\\tmovea lo(%s), r11, r11\\n\\tjarl .+4, r10\\n\\tadd 4, r10\\n\\tjmp r11\"", ",", "name", ",", "name", ")", ";", "}", "else", "{", "if", "(", "first", "==", "last", ")", "sprintf", "(", "buff", ",", "\"jarl __save_%s, r10\"", ",", "reg_names", "[", "first", "]", ")", ";", "else", "sprintf", "(", "buff", ",", "\"jarl __save_%s_%s, r10\"", ",", "reg_names", "[", "first", "]", ",", "reg_names", "[", "last", "]", ")", ";", "}", "return", "buff", ";", "}", "</s>" ]

[ "Construct", "a", "JARL", "instruction", "to", "a", "routine", "that", "will", "perform", "the", "equivalent", "of", "the", "RTL", "passed", "as", "a", "parameter", ".", "This", "RTL", "is", "a", "function", "prologue", "that", "saves", "some", "of", "the", "registers", "r20", "-", "r31", "onto", "the", "stack", ",", "and", "possibly", "acquires", "some", "stack", "space", "as", "well", ".", "The", "code", "has", "already", "verified", "that", "the", "RTL", "matches", "these", "requirements", "." ]

[ "v850", "0", "100", "2", "\"bogus JARL construction: %d\\n\"", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0", "0", "1", "3", "2", "4", "0", "16", "\"bad amount of stack space removal: %d\"", "0", "1", "2", "1", "0", "1", "0", "32", "1", "32", "1", "16", "1", "29", "29", "40", "\"__save_%s\"", "\"__save_%s_%s\"", "\"movhi hi(%s), r0, r11\\n\\tmovea lo(%s), r11, r11\\n\\tjarl .+4, r10\\n\\tadd 4, r10\\n\\tjmp r11\"", "\"jarl __save_%s, r10\"", "\"jarl __save_%s_%s, r10\"" ]

[]

[ "<s>", "unsigned", "AMDGPUInstrInfo", "::", "getOpcodeAfterMemoryUnfold", "(", "unsigned", "Opc", ",", "bool", "UnfoldLoad", ",", "bool", "UnfoldStore", ",", "unsigned", "*", "LoadRegIndex", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

[ "getOpcodeAfterMemoryUnfold", "-", "Returns", "the", "opcode", "of", "the", "would", "be", "new", "instruction", "after", "load", "/", "store", "are", "unfolded", "from", "an", "instruction", "of", "the", "specified", "opcode", "." ]

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

[]

[ "<s>", "bool", "rs6000_builtin_is_supported_p", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "HOST_WIDE_INT", "fnmask", "=", "rs6000_builtin_info", "[", "fncode", "]", ".", "mask", ";", "if", "(", "(", "fnmask", "&", "rs6000_builtin_mask", ")", "!=", "fnmask", ")", "return", "false", ";", "else", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "a", "builtin", "function", "is", "supported", "in", "this", "target", "configuration", "." ]

[ "rs6000" ]

[]

[ "<s>", "bool", "X86ATTAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "break", ";", "case", "'P'", ":", "printOperand", "(", "MI", ",", "OpNo", ",", "\"mem\"", ")", ";", "return", "false", ";", "}", "}", "printMemReference", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "1", "0", "0", "\"mem\"" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "void", "mips_for_each_saved_reg", "(", "HOST_WIDE_INT", "sp_offset", ",", "mips_save_restore_fn", "fn", ")", "{", "enum", "machine_mode", "fpr_mode", ";", "HOST_WIDE_INT", "offset", ";", "int", "regno", ";", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "gp_sp_offset", "-", "sp_offset", ";", "for", "(", "regno", "=", "GP_REG_LAST", ";", "regno", ">=", "GP_REG_FIRST", ";", "regno", "--", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "mips_save_restore_reg", "(", "gpr_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "GET_MODE_SIZE", "(", "gpr_mode", ")", ";", "}", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "fp_sp_offset", "-", "sp_offset", ";", "fpr_mode", "=", "(", "TARGET_SINGLE_FLOAT", "?", "SFmode", ":", "DFmode", ")", ";", "for", "(", "regno", "=", "(", "FP_REG_LAST", "-", "FP_INC", "+", "1", ")", ";", "regno", ">=", "FP_REG_FIRST", ";", "regno", "-=", "FP_INC", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "fmask", ",", "regno", "-", "FP_REG_FIRST", ")", ")", "{", "mips_save_restore_reg", "(", "fpr_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "GET_MODE_SIZE", "(", "fpr_mode", ")", ";", "}", "}", "</s>" ]

[ "Call", "FN", "for", "each", "register", "that", "is", "saved", "by", "the", "current", "function", ".", "SP_OFFSET", "is", "the", "offset", "of", "the", "current", "stack", "pointer", "from", "the", "start", "of", "the", "frame", "." ]

[ "mips", "1" ]

[]

[ "<s>", "Register", "OutgoingValueHandler", "::", "getStackAddress", "(", "const", "CCValAssign", "&", "VA", ",", "MachineMemOperand", "*", "&", "MMO", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFL", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "LLT", "p0", "=", "LLT", "::", "pointer", "(", "0", ",", "32", ")", ";", "LLT", "s32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "Register", "SPReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "SPReg", ",", "Register", "(", "Mips", "::", "SP", ")", ")", ";", "Register", "OffsetReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "s32", ")", ";", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "MIRBuilder", ".", "buildConstant", "(", "OffsetReg", ",", "Offset", ")", ";", "Register", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "p0", ")", ";", "MIRBuilder", ".", "buildPtrAdd", "(", "AddrReg", ",", "SPReg", ",", "OffsetReg", ")", ";", "MachinePointerInfo", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "Offset", ")", ";", "unsigned", "Size", "=", "alignTo", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", ",", "8", ")", "/", "8", ";", "unsigned", "Align", "=", "MinAlign", "(", "TFL", "->", "getStackAlignment", "(", ")", ",", "Offset", ")", ";", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "Mips", "0", "32", "32", "Mips::SP", "8", "8" ]

[]

[ "<s>", "static", "void", "nvptx_output_unisimt_switch", "(", "FILE", "*", "file", ",", "bool", "entering", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "cfun", "->", "machine", "->", "unisimt_predicate", ")", "return", ";", "fprintf", "(", "file", ",", "\"\\t{\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\t.reg.u32 %%ustmp2;\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.u32 %%ustmp2, %d;\\n\"", ",", "entering", "?", "-", "1", ":", "0", ")", ";", "if", "(", "cfun", "->", "machine", "->", "unisimt_outside_simt_predicate", ")", "{", "int", "pred_outside_simt", "=", "REGNO", "(", "cfun", "->", "machine", "->", "unisimt_outside_simt_predicate", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.pred %%r%d, %d;\\n\"", ",", "pred_outside_simt", ",", "entering", "?", "0", ":", "1", ")", ";", "}", "if", "(", "!", "crtl", "->", "is_leaf", ")", "{", "int", "loc", "=", "REGNO", "(", "cfun", "->", "machine", "->", "unisimt_location", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tst.shared.u32 [%%r%d], %%ustmp2;\\n\"", ",", "loc", ")", ";", "}", "if", "(", "cfun", "->", "machine", "->", "unisimt_predicate", ")", "{", "int", "master", "=", "REGNO", "(", "cfun", "->", "machine", "->", "unisimt_master", ")", ";", "int", "pred", "=", "REGNO", "(", "cfun", "->", "machine", "->", "unisimt_predicate", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.u32 %%ustmp2, %%laneid;\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tmov.u32 %%r%d, %s;\\n\"", ",", "master", ",", "entering", "?", "\"%ustmp2\"", ":", "\"0\"", ")", ";", "fprintf", "(", "file", ",", "\"\\t\\tsetp.eq.u32 %%r%d, %%r%d, %%ustmp2;\\n\"", ",", "pred", ",", "master", ")", ";", "}", "fprintf", "(", "file", ",", "\"\\t}\\n\"", ")", ";", "}", "</s>" ]

[ "Output", "code", "for", "switching", "uniform-simt", "state", ".", "ENTERING", "indicates", "whether", "we", "are", "entering", "or", "leaving", "non-uniform", "execution", "region", "." ]

[ "nvptx", "\"\\t{\\n\"", "\"\\t\\t.reg.u32 %%ustmp2;\\n\"", "\"\\t\\tmov.u32 %%ustmp2, %d;\\n\"", "1", "0", "\"\\t\\tmov.pred %%r%d, %d;\\n\"", "0", "1", "\"\\t\\tst.shared.u32 [%%r%d], %%ustmp2;\\n\"", "\"\\t\\tmov.u32 %%ustmp2, %%laneid;\\n\"", "\"\\t\\tmov.u32 %%r%d, %s;\\n\"", "\"%ustmp2\"", "\"0\"", "\"\\t\\tsetp.eq.u32 %%r%d, %%r%d, %%ustmp2;\\n\"", "\"\\t}\\n\"" ]

[]

[ "<s>", "unsigned", "getMaxPrefetchIterationsAhead", "(", ")", "const", "{", "return", "MaxPrefetchIterationsAhead", ";", "}", "</s>" ]

[ "Return", "the", "maximum", "prefetch", "distance", "in", "terms", "of", "loop", "iterations", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "void", "recombine_stvx_pattern", "(", "rtx_insn", "*", "insn", ",", "del_info", "*", "to_delete", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "body", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "body", ")", ")", "==", "MEM", "&&", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", ")", ";", "rtx", "mem", "=", "SET_DEST", "(", "body", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "rtx", "and_operation", "=", "find_alignment_op", "(", "insn", ",", "base_reg", ")", ";", "if", "(", "and_operation", "!=", "0", ")", "{", "rtx", "src_reg", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "df_ref", "src_use", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "FOR_EACH_INSN_INFO_USE", "(", "src_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "src_use", ")", ",", "src_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "src_use", ")", ";", "if", "(", "!", "link", "||", "link", "->", "next", ")", "break", ";", "rtx_insn", "*", "swap_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "!", "insn_is_swap_p", "(", "swap_insn", ")", "||", "insn_is_load_p", "(", "swap_insn", ")", "||", "insn_is_store_p", "(", "swap_insn", ")", ")", "break", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace", "=", "true", ";", "to_delete", "[", "INSN_UID", "(", "swap_insn", ")", "]", ".", "replace_insn", "=", "swap_insn", ";", "XEXP", "(", "mem", ",", "0", ")", "=", "and_operation", ";", "SET_SRC", "(", "body", ")", "=", "src_reg", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "df_insn_rescan", "(", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"stvx opportunity found at %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "If", "INSN", "is", "the", "store", "for", "an", "stvx", "pattern", ",", "put", "it", "in", "canonical", "form", "." ]

[ "rs6000", "0", "0", "0", "0", "1", "\"stvx opportunity found at %d\\n\"" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "TM", "=", "&", "TPC", "->", "getTM", "<", "PPCTargetMachine", ">", "(", ")", ";", "STI", "=", "TM", "->", "getSubtargetImpl", "(", "F", ")", ";", "TLI", "=", "STI", "->", "getTargetLowering", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolutionWrapperPass", ">", "(", ")", ".", "getSE", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "TTI", "=", "&", "getAnalysis", "<", "TargetTransformInfoWrapperPass", ">", "(", ")", ".", "getTTI", "(", "F", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "auto", "*", "TLIP", "=", "getAnalysisIfAvailable", "<", "TargetLibraryInfoWrapperPass", ">", "(", ")", ";", "LibInfo", "=", "TLIP", "?", "&", "TLIP", "->", "getTLI", "(", ")", ":", "nullptr", ";", "PreserveLCSSA", "=", "mustPreserveAnalysisID", "(", "LCSSAID", ")", ";", "SchedModel", ".", "init", "(", "STI", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "MadeChange", "|=", "convertToCTRLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "DeadCodeElimination", "::", "isDead", "(", "unsigned", "R", ")", "const", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MRI", ".", "use_operands", "(", "R", ")", ")", "{", "const", "MachineInstr", "*", "UseI", "=", "MO", ".", "getParent", "(", ")", ";", "if", "(", "UseI", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "UseI", "->", "isPHI", "(", ")", ")", "{", "assert", "(", "!", "UseI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", ")", ";", "Register", "DR", "=", "UseI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "DR", "==", "R", ")", "continue", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

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

[]

[ "<s>", "static", "void", "avr_output_progmem_section_asm_op", "(", "const", "char", "*", "data", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t%s,\\\"a\\\",@progbits\\n\"", ",", "data", ")", ";", "}", "</s>" ]

[ "Unnamed", "section", "callback", "for", "progmem", "*", ".data", "sections", "." ]

[ "avr", "\"\\t.section\\t%s,\\\"a\\\",@progbits\\n\"" ]

[]

[ "<s>", "SDValue", "LanaiTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCCE", ":", "return", "LowerSETCCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "ISD::MUL", "ISD::BR_CC", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SELECT_CC", "ISD::SETCC", "ISD::SETCCE", "ISD::SRL_PARTS", "ISD::VASTART", "ISD::DYNAMIC_STACKALLOC", "ISD::RETURNADDR", "ISD::FRAMEADDR", "\"unimplemented operand\"" ]

[]

[ "<s>", "static", "bool", "ix86_swap_binary_operands_p", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src1", "=", "operands", "[", "1", "]", ";", "rtx", "src2", "=", "operands", "[", "2", "]", ";", "if", "(", "GET_RTX_CLASS", "(", "code", ")", "!=", "RTX_COMM_ARITH", "&&", "GET_RTX_CLASS", "(", "code", ")", "!=", "RTX_COMM_COMPARE", ")", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "dst", ",", "src2", ")", ")", "return", "true", ";", "if", "(", "immediate_operand", "(", "src2", ",", "mode", ")", ")", "return", "false", ";", "if", "(", "immediate_operand", "(", "src1", ",", "mode", ")", ")", "return", "true", ";", "if", "(", "MEM_P", "(", "src2", ")", ")", "return", "false", ";", "if", "(", "MEM_P", "(", "src1", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "of", "ix86_fixup_binary_operands", "to", "canonicalize", "operand", "order", ".", "Returns", "true", "if", "the", "operands", "should", "be", "swapped", "." ]

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

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "TM", "->", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "device", "(", ")", "->", "getGeneration", "(", ")", "<=", "AMDGPUDeviceInfo", "::", "HD6XXX", ")", "{", "addPass", "(", "createAMDGPUCFGPreparationPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createAMDGPUCFGStructurizerPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600EmitClauseMarkers", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600ExpandSpecialInstrsPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "&", "FinalizeMachineBundlesID", ")", ";", "addPass", "(", "createR600Packetizer", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createR600ControlFlowFinalizer", "(", "*", "TM", ")", ")", ";", "}", "else", "{", "addPass", "(", "createSILowerControlFlowPass", "(", "*", "TM", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "R600", "AMDGPUDeviceInfo::HD6XXX", "SI" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "OptForSize", "=", "MF", ".", "getFunction", "(", ")", "->", "optForSize", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Start X86FixupBWInsts\\n\"", "\"End X86FixupBWInsts\\n\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"BPF DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "inline", "struct", "loongarch_abi", "isa_default_abi", "(", "const", "struct", "loongarch_isa", "*", "isa", ")", "{", "struct", "loongarch_abi", "abi", ";", "switch", "(", "isa", "->", "fpu", ")", "{", "case", "ISA_EXT_FPU64", ":", "if", "(", "isa", "->", "base", "==", "ISA_BASE_LA64V100", ")", "abi", ".", "base", "=", "ABI_BASE_LP64D", ";", "break", ";", "case", "ISA_EXT_FPU32", ":", "if", "(", "isa", "->", "base", "==", "ISA_BASE_LA64V100", ")", "abi", ".", "base", "=", "ABI_BASE_LP64F", ";", "break", ";", "case", "ISA_EXT_NOFPU", ":", "if", "(", "isa", "->", "base", "==", "ISA_BASE_LA64V100", ")", "abi", ".", "base", "=", "ABI_BASE_LP64S", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "abi", ".", "ext", "=", "ABI_EXT_BASE", ";", "return", "abi", ";", "}", "</s>" ]

[ "Returns", "the", "default", "ABI", "for", "the", "given", "instruction", "set", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "bool", "is_microcoded_insn", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "NONDEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", ")", "return", "false", ";", "if", "(", "rs6000_tune", "==", "PROCESSOR_CELL", ")", "return", "get_attr_cell_micro", "(", "insn", ")", "==", "CELL_MICRO_ALWAYS", ";", "if", "(", "rs6000_sched_groups", "&&", "(", "rs6000_tune", "==", "PROCESSOR_POWER4", "||", "rs6000_tune", "==", "PROCESSOR_POWER5", ")", ")", "{", "enum", "attr_type", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "(", "type", "==", "TYPE_LOAD", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_sign_extend", "(", "insn", ")", "==", "SIGN_EXTEND_YES", ")", "||", "(", "(", "type", "==", "TYPE_LOAD", "||", "type", "==", "TYPE_STORE", ")", "&&", "get_attr_update", "(", "insn", ")", "==", "UPDATE_YES", "&&", "get_attr_indexed", "(", "insn", ")", "==", "INDEXED_YES", ")", "||", "type", "==", "TYPE_MFCR", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "The", "function", "returns", "a", "true", "if", "INSN", "is", "microcoded", ".", "Return", "false", "otherwise", "." ]

[ "rs6000" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "int", "riscv_flatten_aggregate_argument", "(", "const_tree", "type", ",", "riscv_aggregate_field", "fields", "[", "2", "]", ")", "{", "if", "(", "!", "type", "||", "TREE_CODE", "(", "type", ")", "!=", "RECORD_TYPE", ")", "return", "-", "1", ";", "return", "riscv_flatten_aggregate_field", "(", "type", ",", "fields", ",", "0", ",", "0", ")", ";", "}", "</s>" ]

[ "Identify", "candidate", "aggregates", "for", "passing", "in", "floating-point", "registers", ".", "Candidates", "have", "at", "most", "two", "fields", "after", "flattening", "." ]

[ "riscv", "2", "1", "0", "0" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "2", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "2", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "MSP430", "::", "ADD16ri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "0", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "0", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "MSP430", "MSP430", "0", "\"Unexpected\"", "MSP430::FPW", "MSP430::SPW", "2", "2", "1", "MSP430::ADD16ri", "MSP430::MOV16rr", "0", "0", "0", "MSP430::SUB16ri", "MSP430::ADD16ri", "1" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "List", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "rtx", "mips_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "return", "mips_function_value_1", "(", "valtype", ",", "fn_decl_or_type", ",", "VOIDmode", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_VALUE", "and", "LIBCALL_VALUE", ".", "For", "normal", "calls", ",", "VALTYPE", "is", "the", "return", "type", "and", "MODE", "is", "VOIDmode", ".", "For", "libcalls", ",", "VALTYPE", "is", "null", "and", "MODE", "is", "the", "mode", "of", "the", "return", "value", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "shouldScheduleLoadsNear", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "Offset1", ",", "int64_t", "Offset2", ",", "unsigned", "NumLoads", ")", "const", "{", "assert", "(", "Offset2", ">", "Offset1", ")", ";", "if", "(", "(", "Offset2", "-", "Offset1", ")", "/", "8", ">", "64", ")", "return", "false", ";", "unsigned", "Opc1", "=", "Load1", "->", "getMachineOpcode", "(", ")", ";", "unsigned", "Opc2", "=", "Load2", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "Opc1", "!=", "Opc2", ")", "return", "false", ";", "switch", "(", "Opc1", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "LD_Fp32m", ":", "case", "X86", "::", "LD_Fp64m", ":", "case", "X86", "::", "LD_Fp80m", ":", "case", "X86", "::", "MMX_MOVD64rm", ":", "case", "X86", "::", "MMX_MOVQ64rm", ":", "return", "false", ";", "}", "EVT", "VT", "=", "Load1", "->", "getValueType", "(", "0", ")", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "if", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "NumLoads", ">=", "3", ")", "return", "false", ";", "}", "else", "if", "(", "NumLoads", ")", "{", "return", "false", ";", "}", "break", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "NumLoads", ")", "return", "false", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "shouldScheduleLoadsNear", "-", "This", "is", "a", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "(", "in", "conjunction", "with", "areLoadsFromSameBasePtr", ")", "if", "two", "loads", "should", "be", "scheduled", "togther", "." ]

[ "X86", "X86", "8", "64", "X86::LD_Fp32m", "X86::LD_Fp64m", "X86::LD_Fp80m", "X86::MMX_MOVD64rm", "X86::MMX_MOVQ64rm", "0", "3", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "bool", "OptimizePICCall", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "if", "(", "F", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "inMips16Mode", "(", ")", ")", "return", "false", ";", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "bool", "Changed", "=", "false", ";", "SmallVector", "<", "MBBInfo", ",", "8", ">", "WorkList", "(", "1", ",", "MBBInfo", "(", "MDT", "->", "getRootNode", "(", ")", ")", ")", ";", "while", "(", "!", "WorkList", ".", "empty", "(", ")", ")", "{", "MBBInfo", "&", "MBBI", "=", "WorkList", ".", "back", "(", ")", ";", "if", "(", "MBBI", ".", "isVisited", "(", ")", ")", "{", "MBBI", ".", "postVisit", "(", ")", ";", "WorkList", ".", "pop_back", "(", ")", ";", "continue", ";", "}", "MBBI", ".", "preVisit", "(", "ScopedHT", ")", ";", "Changed", "|=", "visitNode", "(", "MBBI", ")", ";", "const", "MachineDomTreeNode", "*", "Node", "=", "MBBI", ".", "getNode", "(", ")", ";", "WorkList", ".", "append", "(", "Node", "->", "begin", "(", ")", ",", "Node", "->", "end", "(", ")", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "8", "1" ]

[]

[ "<s>", "static", "bool", "ix86_float_exceptions_rounding_supported_p", "(", "void", ")", "{", "return", "TARGET_80387", "||", "TARGET_SSE_MATH", ";", "}", "</s>" ]

[ "Implement", "TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P", "." ]

[ "i386" ]

[]

[ "<s>", "void", "pa_d_target_versions", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "d_add_builtin_version", "(", "\"HPPA64\"", ")", ";", "else", "d_add_builtin_version", "(", "\"HPPA\"", ")", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "d_add_builtin_version", "(", "\"D_SoftFloat\"", ")", ";", "else", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "HPPA", "targets", "." ]

[ "pa", "\"HPPA64\"", "\"HPPA\"", "\"D_SoftFloat\"", "\"D_HardFloat\"" ]

[]

[ "<s>", "static", "void", "s390_end_pool", "(", "struct", "constant_pool", "*", "pool", ",", "rtx", "insn", ")", "{", "rtx", "pool_size", "=", "GEN_INT", "(", "pool", "->", "size", "+", "8", ")", ";", "if", "(", "!", "insn", ")", "insn", "=", "get_last_insn", "(", ")", ";", "pool", "->", "pool_insn", "=", "emit_insn_after", "(", "gen_pool", "(", "pool_size", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "pool", "->", "pool_insn", ",", "-", "1", ")", ";", "}", "</s>" ]

[ "End", "range", "of", "instructions", "covered", "by", "POOL", "at", "INSN", "and", "emit", "placeholder", "insn", "representing", "the", "pool", "." ]

[ "s390", "8", "1" ]

[]