Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "MetadataStreamerV4", "::", "begin", "(", "const", "Module", "&", "Mod", ",", "const", "IsaInfo", "::", "AMDGPUTargetID", "&", "TargetID", ")", "{", "emitVersion", "(", ")", ";", "emitTargetID", "(", "TargetID", ")", ";", "emitPrintf", "(", "Mod", ")", ";", "getRootMetadata", "(", "\"amdhsa.kernels\"", ")", "=", "HSAMetadataDoc", "->", "getArrayNode", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"amdhsa.kernels\"" ]

[]

[ "<s>", "static", "int", "arm_sched_reorder", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "n_readyp", ",", "int", "clock", ")", "{", "switch", "(", "arm_tune", ")", "{", "case", "cortexa7", ":", "cortexa7_sched_reorder", "(", "file", ",", "verbose", ",", "ready", ",", "n_readyp", ",", "clock", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "arm_issue_rate", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SCHED_REORDER", "." ]

[ "arm" ]

[]

[ "<s>", "char", "*", "output_cbranch", "(", "rtx", "op", ",", "const", "char", "*", "label", ",", "int", "reversed", ",", "rtx_insn", "*", "insn", ")", "{", "static", "char", "string", "[", "64", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "cc_reg", "=", "XEXP", "(", "op", ",", "0", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "cc_reg", ")", ";", "int", "cc_regno", "=", "REGNO", "(", "cc_reg", ")", "-", "CR0_REGNO", ";", "int", "need_longbranch", "=", "label", "!=", "NULL", "&&", "get_attr_length", "(", "insn", ")", "==", "8", ";", "int", "really_reversed", "=", "reversed", "^", "need_longbranch", ";", "char", "*", "s", "=", "string", ";", "const", "char", "*", "ccode", ";", "const", "char", "*", "pred", ";", "rtx", "note", ";", "validate_condition_mode", "(", "code", ",", "mode", ")", ";", "if", "(", "really_reversed", ")", "{", "if", "(", "mode", "==", "CCFPmode", ")", "code", "=", "reverse_condition_maybe_unordered", "(", "code", ")", ";", "else", "code", "=", "reverse_condition", "(", "code", ")", ";", "}", "if", "(", "(", "!", "TARGET_FPRS", "&&", "TARGET_HARD_FLOAT", ")", "&&", "mode", "==", "CCFPmode", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "code", "=", "GT", ";", "break", ";", "case", "NE", ":", "code", "=", "UNLE", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "switch", "(", "code", ")", "{", "case", "NE", ":", "case", "LTGT", ":", "ccode", "=", "\"ne\"", ";", "break", ";", "case", "EQ", ":", "case", "UNEQ", ":", "ccode", "=", "\"eq\"", ";", "break", ";", "case", "GE", ":", "case", "GEU", ":", "ccode", "=", "\"ge\"", ";", "break", ";", "case", "GT", ":", "case", "GTU", ":", "case", "UNGT", ":", "ccode", "=", "\"gt\"", ";", "break", ";", "case", "LE", ":", "case", "LEU", ":", "ccode", "=", "\"le\"", ";", "break", ";", "case", "LT", ":", "case", "LTU", ":", "case", "UNLT", ":", "ccode", "=", "\"lt\"", ";", "break", ";", "case", "UNORDERED", ":", "ccode", "=", "\"un\"", ";", "break", ";", "case", "ORDERED", ":", "ccode", "=", "\"nu\"", ";", "break", ";", "case", "UNGE", ":", "ccode", "=", "\"nl\"", ";", "break", ";", "case", "UNLE", ":", "ccode", "=", "\"ng\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "pred", "=", "\"\"", ";", "note", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "NULL_RTX", ")", ";", "if", "(", "note", "!=", "NULL_RTX", ")", "{", "int", "prob", "=", "XINT", "(", "note", ",", "0", ")", "-", "REG_BR_PROB_BASE", "/", "2", ";", "if", "(", "rs6000_always_hint", "||", "(", "abs", "(", "prob", ")", ">", "REG_BR_PROB_BASE", "/", "100", "*", "48", "&&", "br_prob_note_reliable_p", "(", "note", ")", ")", ")", "{", "if", "(", "abs", "(", "prob", ")", ">", "REG_BR_PROB_BASE", "/", "20", "&&", "(", "(", "prob", ">", "0", ")", "^", "need_longbranch", ")", ")", "pred", "=", "\"+\"", ";", "else", "pred", "=", "\"-\"", ";", "}", "}", "if", "(", "label", "==", "NULL", ")", "s", "+=", "sprintf", "(", "s", ",", "\"b%slr%s \"", ",", "ccode", ",", "pred", ")", ";", "else", "s", "+=", "sprintf", "(", "s", ",", "\"b%s%s \"", ",", "ccode", ",", "pred", ")", ";", "if", "(", "reg_names", "[", "cc_regno", "+", "CR0_REGNO", "]", "[", "0", "]", "==", "'%'", ")", "*", "s", "++", "=", "'%'", ";", "s", "+=", "sprintf", "(", "s", ",", "\"%s\"", ",", "reg_names", "[", "cc_regno", "+", "CR0_REGNO", "]", ")", ";", "if", "(", "label", "!=", "NULL", ")", "{", "if", "(", "need_longbranch", ")", "s", "+=", "sprintf", "(", "s", ",", "\",$+8\\n\\tb %s\"", ",", "label", ")", ";", "else", "s", "+=", "sprintf", "(", "s", ",", "\",%s\"", ",", "label", ")", ";", "}", "return", "string", ";", "}", "</s>" ]

[ "Output", "a", "conditional", "branch", "to", "LABEL", ".", "CODE", "is", "the", "comparison", "code", ".", "CC_MODE", "is", "the", "mode", "of", "the", "CC", "register", ".", "REVERSED", "is", "non-zero", "if", "we", "should", "reverse", "the", "sense", "of", "the", "comparison", ".", "INSN", "is", "the", "instruction", "." ]

[ "rs6000", "64", "0", "8", "\"ne\"", "\"eq\"", "\"ge\"", "\"gt\"", "\"le\"", "\"lt\"", "\"un\"", "\"nu\"", "\"nl\"", "\"ng\"", "\"\"", "0", "2", "100", "48", "20", "0", "\"+\"", "\"-\"", "\"b%slr%s \"", "\"b%s%s \"", "0", "\"%s\"", "\",$+8\\n\\tb %s\"", "\",%s\"" ]

[]

[ "<s>", "static", "int", "getRegClass", "(", "RegisterKind", "Is", ",", "unsigned", "RegWidth", ")", "{", "if", "(", "Is", "==", "IS_VGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "VGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "VReg_64RegClassID", ";", "case", "3", ":", "return", "AMDGPU", "::", "VReg_96RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "VReg_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "VReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "VReg_512RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_TTMP", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "TTMP_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "TTMP_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "TTMP_128RegClassID", ";", "}", "}", "else", "if", "(", "Is", "==", "IS_SGPR", ")", "{", "switch", "(", "RegWidth", ")", "{", "default", ":", "return", "-", "1", ";", "case", "1", ":", "return", "AMDGPU", "::", "SGPR_32RegClassID", ";", "case", "2", ":", "return", "AMDGPU", "::", "SGPR_64RegClassID", ";", "case", "4", ":", "return", "AMDGPU", "::", "SGPR_128RegClassID", ";", "case", "8", ":", "return", "AMDGPU", "::", "SReg_256RegClassID", ";", "case", "16", ":", "return", "AMDGPU", "::", "SReg_512RegClassID", ";", "}", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "AMDGPU", "1", "1", "AMDGPU::VGPR_32RegClassID", "2", "AMDGPU::VReg_64RegClassID", "3", "AMDGPU::VReg_96RegClassID", "4", "AMDGPU::VReg_128RegClassID", "8", "AMDGPU::VReg_256RegClassID", "16", "AMDGPU::VReg_512RegClassID", "1", "1", "AMDGPU::TTMP_32RegClassID", "2", "AMDGPU::TTMP_64RegClassID", "4", "AMDGPU::TTMP_128RegClassID", "1", "1", "AMDGPU::SGPR_32RegClassID", "2", "AMDGPU::SGPR_64RegClassID", "4", "AMDGPU::SGPR_128RegClassID", "8", "AMDGPU::SReg_256RegClassID", "16", "AMDGPU::SReg_512RegClassID", "1" ]

[]

[ "<s>", "std", "::", "string", "BTFTypeStruct", "::", "getName", "(", ")", "{", "return", "std", "::", "string", "(", "STy", "->", "getName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "BPF" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getSqrtEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "ExtraSteps", ",", "bool", "&", "UseOneConst", ",", "bool", "Reciprocal", ")", "const", "{", "if", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Enabled", "||", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Unspecified", "&&", "Subtarget", "->", "useRSqrt", "(", ")", ")", ")", "if", "(", "SDValue", "Estimate", "=", "getEstimate", "(", "Subtarget", ",", "AArch64ISD", "::", "FRSQRTE", ",", "Operand", ",", "DAG", ",", "ExtraSteps", ")", ")", "{", "SDLoc", "DL", "(", "Operand", ")", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", ";", "Flags", ".", "setAllowReassociation", "(", "true", ")", ";", "for", "(", "int", "i", "=", "ExtraSteps", ";", "i", ">", "0", ";", "--", "i", ")", "{", "SDValue", "Step", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Estimate", ",", "Flags", ")", ";", "Step", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "FRSQRTS", ",", "DL", ",", "VT", ",", "Operand", ",", "Step", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Step", ",", "Flags", ")", ";", "}", "if", "(", "!", "Reciprocal", ")", "{", "EVT", "CCVT", "=", "getSetCCResultType", "(", "DAG", ".", "getDataLayout", "(", ")", ",", "*", "DAG", ".", "getContext", "(", ")", ",", "VT", ")", ";", "SDValue", "FPZero", "=", "DAG", ".", "getConstantFP", "(", "0.0", ",", "DL", ",", "VT", ")", ";", "SDValue", "Eq", "=", "DAG", ".", "getSetCC", "(", "DL", ",", "CCVT", ",", "Operand", ",", "FPZero", ",", "ISD", "::", "SETEQ", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Operand", ",", "Estimate", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "VT", ".", "isVector", "(", ")", "?", "ISD", "::", "VSELECT", ":", "ISD", "::", "SELECT", ",", "DL", ",", "VT", ",", "Eq", ",", "Operand", ",", "Estimate", ")", ";", "}", "ExtraSteps", "=", "0", ";", "return", "Estimate", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Hooks", "for", "building", "estimates", "in", "place", "of", "slower", "divisions", "and", "square", "roots", "." ]

[ "AArch64", "AArch64", "AArch64ISD::FRSQRTE", "0", "ISD::FMUL", "AArch64ISD::FRSQRTS", "ISD::FMUL", "0.0", "ISD::SETEQ", "ISD::FMUL", "ISD::VSELECT", "ISD::SELECT", "0" ]

[]

[ "<s>", "bool", "DLXInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Condition", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "rtx", "gen_compare_reg_1", "(", "enum", "rtx_code", "code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "machine_mode", "mode", ";", "rtx", "cc_reg", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_CC", ")", "return", "x", ";", "mode", "=", "SELECT_CC_MODE", "(", "code", ",", "x", ",", "y", ")", ";", "if", "(", "TARGET_V9", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "int", "reg", ";", "static", "int", "next_fcc_reg", "=", "0", ";", "static", "rtx", "prev_args", "[", "4", "]", "[", "2", "]", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "4", ";", "reg", "++", ")", "if", "(", "prev_args", "[", "reg", "]", "[", "0", "]", "==", "x", "&&", "prev_args", "[", "reg", "]", "[", "1", "]", "==", "y", ")", "break", ";", "if", "(", "reg", "==", "4", ")", "{", "reg", "=", "next_fcc_reg", ";", "prev_args", "[", "reg", "]", "[", "0", "]", "=", "x", ";", "prev_args", "[", "reg", "]", "[", "1", "]", "=", "y", ";", "next_fcc_reg", "=", "(", "next_fcc_reg", "+", "1", ")", "&", "3", ";", "}", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "reg", "+", "SPARC_FIRST_V9_FCC_REG", ")", ";", "}", "cc_reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "else", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "SPARC_FCC_REG", ")", ";", "else", "cc_reg", "=", "gen_rtx_REG", "(", "mode", ",", "SPARC_ICC_REG", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "cc_reg", ",", "gen_rtx_COMPARE", "(", "mode", ",", "x", ",", "y", ")", ")", ")", ";", "return", "cc_reg", ";", "}", "</s>" ]

[ "Emit", "the", "compare", "insn", "and", "return", "the", "CC", "reg", "for", "a", "CODE", "comparison", "with", "operands", "X", "and", "Y", "." ]

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

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "ARM64" ]

[]

[ "<s>", "bool", "SIRegisterInfo", "::", "eliminateSGPRToVGPRSpillFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "int", "FI", ",", "RegScavenger", "*", "RS", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ":", "return", "spillSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "true", ")", ";", "case", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S160_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S96_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ":", "case", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ":", "return", "restoreSGPR", "(", "MI", ",", "FI", ",", "RS", ",", "true", ")", ";", "default", ":", "llvm_unreachable", "(", "\"not an SGPR spill instruction\"", ")", ";", "}", "}", "</s>" ]

[ "Special", "case", "of", "eliminateFrameIndex", "." ]

[ "AMDGPU", "SI", "AMDGPU::SI_SPILL_S512_SAVE", "AMDGPU::SI_SPILL_S256_SAVE", "AMDGPU::SI_SPILL_S160_SAVE", "AMDGPU::SI_SPILL_S128_SAVE", "AMDGPU::SI_SPILL_S96_SAVE", "AMDGPU::SI_SPILL_S64_SAVE", "AMDGPU::SI_SPILL_S32_SAVE", "AMDGPU::SI_SPILL_S512_RESTORE", "AMDGPU::SI_SPILL_S256_RESTORE", "AMDGPU::SI_SPILL_S160_RESTORE", "AMDGPU::SI_SPILL_S128_RESTORE", "AMDGPU::SI_SPILL_S96_RESTORE", "AMDGPU::SI_SPILL_S64_RESTORE", "AMDGPU::SI_SPILL_S32_RESTORE", "\"not an SGPR spill instruction\"" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "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>", "bool", "AArch64InstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isCortexA57", "(", ")", "&&", "!", "Subtarget", ".", "isCortexA53", "(", ")", ")", "return", "MI", "->", "isAsCheapAsAMove", "(", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "return", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "case", "AArch64", "::", "ANDWri", ":", "case", "AArch64", "::", "ANDXri", ":", "case", "AArch64", "::", "EORWri", ":", "case", "AArch64", "::", "EORXri", ":", "case", "AArch64", "::", "ORRWri", ":", "case", "AArch64", "::", "ORRXri", ":", "return", "true", ";", "case", "AArch64", "::", "ANDWrr", ":", "case", "AArch64", "::", "ANDXrr", ":", "case", "AArch64", "::", "BICWrr", ":", "case", "AArch64", "::", "BICXrr", ":", "case", "AArch64", "::", "EONWrr", ":", "case", "AArch64", "::", "EONXrr", ":", "case", "AArch64", "::", "EORWrr", ":", "case", "AArch64", "::", "EORXrr", ":", "case", "AArch64", "::", "ORNWrr", ":", "case", "AArch64", "::", "ORNXrr", ":", "case", "AArch64", "::", "ORRWrr", ":", "case", "AArch64", "::", "ORRXrr", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Unknown opcode to check as cheap as a move!\"", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "AArch64", "AArch64", "AArch64::ADDWri", "AArch64::ADDXri", "AArch64::SUBWri", "AArch64::SUBXri", "3", "0", "AArch64::ANDWri", "AArch64::ANDXri", "AArch64::EORWri", "AArch64::EORXri", "AArch64::ORRWri", "AArch64::ORRXri", "AArch64::ANDWrr", "AArch64::ANDXrr", "AArch64::BICWrr", "AArch64::BICXrr", "AArch64::EONWrr", "AArch64::EONXrr", "AArch64::EORWrr", "AArch64::EORXrr", "AArch64::ORNWrr", "AArch64::ORNXrr", "AArch64::ORRWrr", "AArch64::ORRXrr", "\"Unknown opcode to check as cheap as a move!\"" ]

[]

[ "<s>", "rtx", "arc_regno_use_in", "(", "unsigned", "int", "regno", ",", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ",", "j", ";", "rtx", "tem", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "refers_to_regno_p", "(", "regno", ",", "x", ")", ")", "return", "x", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'e'", ")", "{", "if", "(", "(", "tem", "=", "regno_use_in", "(", "regno", ",", "XEXP", "(", "x", ",", "i", ")", ")", ")", ")", "return", "tem", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "(", "tem", "=", "regno_use_in", "(", "regno", ",", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", ")", "return", "tem", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Searches", "X", "for", "any", "reference", "to", "REGNO", ",", "returning", "the", "rtx", "of", "the", "reference", "found", "if", "any", ".", "Otherwise", ",", "returns", "NULL_RTX", "." ]

[ "arc", "1", "0", "1", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Mips Hazard Schedule\"", ";", "}", "</s>" ]

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

[ "Mips", "\"Mips Hazard Schedule\"" ]

[]

[ "<s>", "static", "rtx", "nios2_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "if", "(", "fcode", "<", "nios2_fpu_builtin_base", ")", "{", "const", "struct", "nios2_builtin_desc", "*", "d", "=", "&", "nios2_builtins", "[", "fcode", "]", ";", "switch", "(", "fcode", ")", "{", "case", "NIOS2_BUILTIN_sync", ":", "emit_insn", "(", "gen_sync", "(", ")", ")", ";", "return", "const0_rtx", ";", "case", "NIOS2_BUILTIN_ldbio", ":", "case", "NIOS2_BUILTIN_ldbuio", ":", "case", "NIOS2_BUILTIN_ldhio", ":", "case", "NIOS2_BUILTIN_ldhuio", ":", "case", "NIOS2_BUILTIN_ldwio", ":", "case", "NIOS2_BUILTIN_stbio", ":", "case", "NIOS2_BUILTIN_sthio", ":", "case", "NIOS2_BUILTIN_stwio", ":", "return", "nios2_expand_ldstio_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "case", "NIOS2_BUILTIN_rdctl", ":", "case", "NIOS2_BUILTIN_wrctl", ":", "return", "nios2_expand_rdwrctl_builtin", "(", "exp", ",", "target", ",", "d", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "if", "(", "fcode", "<", "nios2_custom_builtin_base", ")", "return", "nios2_expand_fpu_builtin", "(", "exp", ",", "fcode", "-", "nios2_fpu_builtin_base", ",", "target", ")", ";", "else", "if", "(", "fcode", "<", "nios2_custom_builtin_end", ")", "return", "nios2_expand_custom_builtin", "(", "exp", ",", "fcode", "-", "nios2_custom_builtin_base", ",", "target", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", ".", "Expand", "an", "expression", "EXP", "that", "calls", "a", "built-in", "function", ",", "with", "result", "going", "to", "TARGET", "if", "that", "'s", "convenient", "(", "and", "in", "mode", "MODE", "if", "that", "'s", "convenient", ")", ".", "SUBTARGET", "may", "be", "used", "as", "the", "target", "for", "computing", "one", "of", "EXP", "'s", "operands", ".", "IGNORE", "is", "nonzero", "if", "the", "value", "is", "to", "be", "ignored", "." ]

[ "nios2", "0" ]

[]

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

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

[ "ARM", "\"ARM Assembly Printer\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Partial Reduction\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Partial Reduction\"" ]

[]

[ "<s>", "void", "SystemZAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "isOSzOS", "(", ")", ")", "{", "MCSymbol", "*", "FnEndSym", "=", "createTempSymbol", "(", "\"func_end\"", ")", ";", "OutStreamer", "->", "emitLabel", "(", "FnEndSym", ")", ";", "OutStreamer", "->", "PushSection", "(", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getPPA1Section", "(", ")", ")", ";", "emitPPA1", "(", "FnEndSym", ")", ";", "OutStreamer", "->", "PopSection", "(", ")", ";", "CurrentFnPPA1Sym", "=", "nullptr", ";", "CurrentFnEPMarkerSym", "=", "nullptr", ";", "}", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "SystemZ", "SystemZ", "\"func_end\"" ]

[]

[ "<s>", "bool", "AMDGPURewriteOutArguments", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "DL", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "isMem", "(", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "PatmosFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "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", "=", "*", "TM", ".", "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", ")", ";", "prior", "(", "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", ")", ";", "prior", "(", "MI", ")", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "tmpReg", "!=", "Reg", ")", "{", "TII", ".", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "Reg", ",", "tmpReg", ",", "true", ")", ";", "prior", "(", "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>", "int", "lm32_expand_block_move", "(", "rtx", "*", "operands", ")", "{", "if", "(", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "&&", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "32", ")", ")", "{", "lm32_block_move_inline", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "INTVAL", "(", "operands", "[", "2", "]", ")", ",", "INTVAL", "(", "operands", "[", "3", "]", ")", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Expand", "string/block", "move", "operations", ".", "operands", "[", "0", "]", "is", "the", "pointer", "to", "the", "destination", ".", "operands", "[", "1", "]", "is", "the", "pointer", "to", "the", "source", ".", "operands", "[", "2", "]", "is", "the", "number", "of", "bytes", "to", "move", ".", "operands", "[", "3", "]", "is", "the", "alignment", "." ]

[ "lm32", "2", "2", "32", "0", "1", "2", "3", "1", "0" ]

[]

[ "<s>", "Optional", "<", "Value", "*", ">", "X86TTIImpl", "::", "simplifyDemandedUseBitsIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ",", "APInt", "DemandedMask", ",", "KnownBits", "&", "Known", ",", "bool", "&", "KnownBitsComputed", ")", "const", "{", "switch", "(", "II", ".", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "x86_mmx_pmovmskb", ":", "case", "Intrinsic", "::", "x86_sse_movmsk_ps", ":", "case", "Intrinsic", "::", "x86_sse2_movmsk_pd", ":", "case", "Intrinsic", "::", "x86_sse2_pmovmskb_128", ":", "case", "Intrinsic", "::", "x86_avx_movmsk_ps_256", ":", "case", "Intrinsic", "::", "x86_avx_movmsk_pd_256", ":", "case", "Intrinsic", "::", "x86_avx2_pmovmskb", ":", "{", "unsigned", "ArgWidth", ";", "if", "(", "II", ".", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "x86_mmx_pmovmskb", ")", "{", "ArgWidth", "=", "8", ";", "}", "else", "{", "auto", "Arg", "=", "II", ".", "getArgOperand", "(", "0", ")", ";", "auto", "ArgType", "=", "cast", "<", "FixedVectorType", ">", "(", "Arg", "->", "getType", "(", ")", ")", ";", "ArgWidth", "=", "ArgType", "->", "getNumElements", "(", ")", ";", "}", "APInt", "DemandedElts", "=", "DemandedMask", ".", "zextOrTrunc", "(", "ArgWidth", ")", ";", "Type", "*", "VTy", "=", "II", ".", "getType", "(", ")", ";", "if", "(", "DemandedElts", ".", "isNullValue", "(", ")", ")", "{", "return", "ConstantInt", "::", "getNullValue", "(", "VTy", ")", ";", "}", "Known", ".", "Zero", ".", "setBitsFrom", "(", "ArgWidth", ")", ";", "KnownBitsComputed", "=", "true", ";", "break", ";", "}", "}", "return", "None", ";", "}", "</s>" ]

[ "Can", "be", "used", "to", "implement", "target-specific", "instruction", "combining", "." ]

[ "X86", "X86", "Intrinsic::x86_mmx_pmovmskb", "Intrinsic::x86_sse_movmsk_ps", "Intrinsic::x86_sse2_movmsk_pd", "Intrinsic::x86_sse2_pmovmskb_128", "Intrinsic::x86_avx_movmsk_ps_256", "Intrinsic::x86_avx_movmsk_pd_256", "Intrinsic::x86_avx2_pmovmskb", "Intrinsic::x86_mmx_pmovmskb", "8", "0" ]

[]

[ "<s>", "bool", "AVRFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "{", "return", "false", ";", "}", "unsigned", "CalleeFrameSize", "=", "0", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AVRFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "IsNotLiveIn", "=", "!", "MBB", ".", "isLiveIn", "(", "Reg", ")", ";", "assert", "(", "TRI", "->", "getRegSizeInBits", "(", "*", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ")", "==", "8", "&&", "\"Invalid register size\"", ")", ";", "if", "(", "IsNotLiveIn", ")", "{", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "AVR", "::", "PUSHRr", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsNotLiveIn", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "CalleeFrameSize", ";", "}", "AVRFI", "->", "setCalleeSavedFrameSize", "(", "CalleeFrameSize", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "AVR", "AVR", "AVR", "AVR", "AVR", "0", "1", "8", "\"Invalid register size\"", "AVR::PUSHRr", "AVR" ]

[]

[ "<s>", "char", "*", "aarch64_output_sve_ptrues", "(", "rtx", "const_unspec", ")", "{", "static", "char", "templ", "[", "40", "]", ";", "struct", "simd_immediate_info", "info", ";", "bool", "is_valid", "=", "aarch64_simd_valid_immediate", "(", "const_unspec", ",", "&", "info", ")", ";", "gcc_assert", "(", "is_valid", "&&", "info", ".", "insn", "==", "simd_immediate_info", "::", "PTRUE", ")", ";", "char", "element_char", "=", "sizetochar", "(", "GET_MODE_BITSIZE", "(", "info", ".", "elt_mode", ")", ")", ";", "snprintf", "(", "templ", ",", "sizeof", "(", "templ", ")", ",", "\"ptrues\\t%%0.%c, %s\"", ",", "element_char", ",", "svpattern_token", "(", "info", ".", "u", ".", "pattern", ")", ")", ";", "return", "templ", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "for", "a", "PTRUES", ".", "CONST_UNSPEC", "is", "the", "aarch64_sve_ptrue_svpattern_immediate", "that", "describes", "the", "predicate", "pattern", "." ]

[ "aarch64", "40", "\"ptrues\\t%%0.%c, %s\"" ]

[]

[ "<s>", "static", "void", "ATTRIBUTE_UNUSED", "mips_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "switch", "(", "size", ")", "{", "case", "4", ":", "fputs", "(", "\"\\t.dtprelword\\t\"", ",", "file", ")", ";", "break", ";", "case", "8", ":", "fputs", "(", "\"\\t.dtpreldword\\t\"", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"+0x8000\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_DWARF_DTPREL", "." ]

[ "mips", "4", "\"\\t.dtprelword\\t\"", "8", "\"\\t.dtpreldword\\t\"", "\"+0x8000\"" ]

[]

[ "<s>", "TargetIRAnalysis", "ARCTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "ARCTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "ARC", "ARC", "ARC" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "decomposeMulByConstant", "(", "EVT", "VT", ",", "SDValue", "C", ")", "const", "{", "APInt", "MulC", ";", "if", "(", "!", "ISD", "::", "isConstantSplatVector", "(", "C", ".", "getNode", "(", ")", ",", "MulC", ")", ")", "return", "false", ";", "if", "(", "isOperationLegal", "(", "ISD", "::", "MUL", ",", "VT", ")", ")", "return", "false", ";", "return", "(", "MulC", "+", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "MulC", "-", "1", ")", ".", "isPowerOf2", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "transform", "an", "integer", "multiplication-by-constant", "into", "simpler", "operations", "like", "shifts", "and", "adds", "." ]

[ "X86", "X86", "ISD::isConstantSplatVector", "ISD::MUL", "1", "1" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "32", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

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

[ "ARM", "1", "2", "4", "8", "\"Unsupported size\"", "32" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "GCNPassConfig", "::", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "{", "const", "GCNSubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "enableSIScheduler", "(", ")", ")", "return", "createSIMachineScheduler", "(", "C", ")", ";", "return", "createGCNMaxOccupancyMachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

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

[]

[ "<s>", "Optional", "<", "Value", "*", ">", "ARMTTIImpl", "::", "simplifyDemandedVectorEltsIntrinsic", "(", "InstCombiner", "&", "IC", ",", "IntrinsicInst", "&", "II", ",", "APInt", "OrigDemandedElts", ",", "APInt", "&", "UndefElts", ",", "APInt", "&", "UndefElts2", ",", "APInt", "&", "UndefElts3", ",", "std", "::", "function", "<", "void", "(", "Instruction", "*", ",", "unsigned", ",", "APInt", ",", "APInt", "&", ")", ">", "SimplifyAndSetOp", ")", "const", "{", "auto", "SimplifyNarrowInstrTopBottom", "=", "[", "&", "]", "(", "unsigned", "TopOpc", ")", "{", "unsigned", "NumElts", "=", "cast", "<", "FixedVectorType", ">", "(", "II", ".", "getType", "(", ")", ")", "->", "getNumElements", "(", ")", ";", "unsigned", "IsTop", "=", "cast", "<", "ConstantInt", ">", "(", "II", ".", "getOperand", "(", "TopOpc", ")", ")", "->", "getZExtValue", "(", ")", ";", "APInt", "DemandedElts", "=", "APInt", "::", "getSplat", "(", "NumElts", ",", "IsTop", "?", "APInt", "::", "getLowBitsSet", "(", "2", ",", "1", ")", ":", "APInt", "::", "getHighBitsSet", "(", "2", ",", "1", ")", ")", ";", "SimplifyAndSetOp", "(", "&", "II", ",", "0", ",", "OrigDemandedElts", "&", "DemandedElts", ",", "UndefElts", ")", ";", "UndefElts", "&=", "APInt", "::", "getSplat", "(", "NumElts", ",", "!", "IsTop", "?", "APInt", "::", "getLowBitsSet", "(", "2", ",", "1", ")", ":", "APInt", "::", "getHighBitsSet", "(", "2", ",", "1", ")", ")", ";", "return", "None", ";", "}", ";", "switch", "(", "II", ".", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "arm_mve_vcvt_narrow", ":", "SimplifyNarrowInstrTopBottom", "(", "2", ")", ";", "break", ";", "case", "Intrinsic", "::", "arm_mve_vqmovn", ":", "SimplifyNarrowInstrTopBottom", "(", "4", ")", ";", "break", ";", "case", "Intrinsic", "::", "arm_mve_vshrn", ":", "SimplifyNarrowInstrTopBottom", "(", "7", ")", ";", "break", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "Can", "be", "used", "to", "implement", "target-specific", "instruction", "combining", "." ]

[ "ARM", "ARM", "2", "1", "2", "1", "0", "2", "1", "2", "1", "Intrinsic::arm_mve_vcvt_narrow", "2", "Intrinsic::arm_mve_vqmovn", "4", "Intrinsic::arm_mve_vshrn", "7" ]

[]

[ "<s>", "unsigned", "MipsAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "*", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint64_t", "MaxReach", "=", "(", "MFFrame", "->", "estimateStackSize", "(", "MF", ")", "+", "SystemZMC", "::", "CallFrameSize", "*", "2", ")", ";", "if", "(", "!", "isUInt", "<", "12", ">", "(", "MaxReach", ")", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", "->", "CreateStackObject", "(", "8", ",", "8", ",", "false", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", "->", "CreateStackObject", "(", "8", ",", "8", ",", "false", ")", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZMC::CallFrameSize", "2", "12", "8", "8", "8", "8" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedBits", ",", "const", "APInt", "&", "DemandedElts", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "int", "NumElts", "=", "DemandedElts", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "X86ISD", "::", "PINSRB", ":", "case", "X86ISD", "::", "PINSRW", ":", "{", "SDValue", "Vec", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "auto", "*", "CIdx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "MVT", "VecVT", "=", "Vec", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "CIdx", "&&", "CIdx", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "VecVT", ".", "getVectorNumElements", "(", ")", ")", "&&", "!", "DemandedElts", "[", "CIdx", "->", "getZExtValue", "(", ")", "]", ")", "return", "Vec", ";", "break", ";", "}", "}", "APInt", "ShuffleUndef", ",", "ShuffleZero", ";", "SmallVector", "<", "int", ",", "16", ">", "ShuffleMask", ";", "SmallVector", "<", "SDValue", ",", "2", ">", "ShuffleOps", ";", "if", "(", "getTargetShuffleInputs", "(", "Op", ",", "DemandedElts", ",", "ShuffleOps", ",", "ShuffleMask", ",", "ShuffleUndef", ",", "ShuffleZero", ",", "DAG", ",", "Depth", ",", "false", ")", ")", "{", "int", "NumOps", "=", "ShuffleOps", ".", "size", "(", ")", ";", "if", "(", "ShuffleMask", ".", "size", "(", ")", "==", "(", "unsigned", ")", "NumElts", "&&", "llvm", "::", "all_of", "(", "ShuffleOps", ",", "[", "VT", "]", "(", "SDValue", "V", ")", "{", "return", "VT", ".", "getSizeInBits", "(", ")", "==", "V", ".", "getValueSizeInBits", "(", ")", ";", "}", ")", ")", "{", "if", "(", "DemandedElts", ".", "isSubsetOf", "(", "ShuffleUndef", ")", ")", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "if", "(", "DemandedElts", ".", "isSubsetOf", "(", "ShuffleUndef", "|", "ShuffleZero", ")", ")", "return", "getZeroVector", "(", "VT", ".", "getSimpleVT", "(", ")", ",", "Subtarget", ",", "DAG", ",", "SDLoc", "(", "Op", ")", ")", ";", "APInt", "IdentityOp", "=", "APInt", "::", "getAllOnesValue", "(", "NumOps", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "int", "M", "=", "ShuffleMask", "[", "i", "]", ";", "if", "(", "!", "DemandedElts", "[", "i", "]", "||", "ShuffleUndef", "[", "i", "]", ")", "continue", ";", "int", "Op", "=", "M", "/", "NumElts", ";", "int", "Index", "=", "M", "%", "NumElts", ";", "if", "(", "M", "<", "0", "||", "Index", "!=", "i", ")", "{", "IdentityOp", ".", "clearAllBits", "(", ")", ";", "break", ";", "}", "IdentityOp", "&=", "APInt", "::", "getOneBitSet", "(", "NumOps", ",", "Op", ")", ";", "if", "(", "IdentityOp", "==", "0", ")", "break", ";", "}", "assert", "(", "(", "IdentityOp", "==", "0", "||", "IdentityOp", ".", "countPopulation", "(", ")", "==", "1", ")", "&&", "\"Multiple identity shuffles detected\"", ")", ";", "if", "(", "IdentityOp", "!=", "0", ")", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "ShuffleOps", "[", "IdentityOp", ".", "countTrailingZeros", "(", ")", "]", ")", ";", "}", "}", "return", "TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "Op", ",", "DemandedBits", ",", "DemandedElts", ",", "DAG", ",", "Depth", ")", ";", "}", "</s>" ]

[ "More", "limited", "version", "of", "SimplifyDemandedBits", "that", "can", "be", "used", "to", "``", "look", "through", "''", "ops", "that", "do", "n't", "contribute", "to", "the", "DemandedBits/DemandedElts", "-", "bitwise", "ops", "etc", "." ]

[ "X86", "X86", "X86ISD::PINSRB", "X86ISD::PINSRW", "0", "2", "16", "2", "0", "0", "0", "0", "1", "\"Multiple identity shuffles detected\"", "0" ]

[]

[ "<s>", "rtl_opt_pass", "*", "make_pass_fma_steering", "(", "gcc", "::", "context", "*", "ctxt", ")", "{", "return", "new", "pass_fma_steering", "(", "ctxt", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "fma", "steering", "pass", "instance", "." ]

[ "aarch64" ]

[]

[ "<s>", "rtx", "mips_gen_const_int_vector", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "rtx", "c", "=", "gen_int_mode", "(", "val", ",", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "return", "gen_const_vec_duplicate", "(", "mode", ",", "c", ")", ";", "}", "</s>" ]

[ "Return", "a", "const_int", "vector", "of", "VAL", "with", "mode", "MODE", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", "->", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isCommutable", "(", ")", ")", "return", "false", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "if", "(", "Src0Idx", "==", "-", "1", ")", "return", "false", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "Src0Idx", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "false", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "if", "(", "hasModifiersSet", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", "||", "hasModifiersSet", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ")", "return", "false", ";", "SrcOpIdx1", "=", "Src0Idx", ";", "SrcOpIdx2", "=", "Src1Idx", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::OpName", "AMDGPU::OpName" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "DataLayout", "(", "\"E-p:32:32-f128:128:128\"", ")", ",", "Subtarget", "(", "TT", ",", "FS", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "FrameInfo", "(", "TargetFrameInfo", "::", "StackGrowsDown", ",", "8", ",", "0", ")", "{", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc", "\"E-p:32:32-f128:128:128\"", "8", "0" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "GCNRegPressure", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "GCNSubtarget", "*", "ST", ")", "const", "{", "OS", "<<", "\"VGPRs: \"", "<<", "getVGPRNum", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\"(O\"", "<<", "ST", "->", "getOccupancyWithNumVGPRs", "(", "getVGPRNum", "(", ")", ")", "<<", "')'", ";", "OS", "<<", "\", SGPRs: \"", "<<", "getSGPRNum", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\"(O\"", "<<", "ST", "->", "getOccupancyWithNumSGPRs", "(", "getSGPRNum", "(", ")", ")", "<<", "')'", ";", "OS", "<<", "\", LVGPR WT: \"", "<<", "getVGPRTuplesWeight", "(", ")", "<<", "\", LSGPR WT: \"", "<<", "getSGPRTuplesWeight", "(", ")", ";", "if", "(", "ST", ")", "OS", "<<", "\" -> Occ: \"", "<<", "getOccupancy", "(", "*", "ST", ")", ";", "OS", "<<", "'\\n'", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AMDGPU", "\"VGPRs: \"", "\"(O\"", "\", SGPRs: \"", "\"(O\"", "\", LVGPR WT: \"", "\", LSGPR WT: \"", "\" -> Occ: \"" ]

[]

[ "<s>", "SDValue", "TLCS900TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_TLCS900", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "TLCS900", "TLCS900", "ISD::InputArg", "16", "TLCS900", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "bool", "s390_handle_arch_option", "(", "const", "char", "*", "arg", ",", "enum", "processor_type", "*", "type", ",", "enum", "processor_flags", "*", "flags", ")", "{", "static", "struct", "pta", "{", "const", "char", "*", "const", "name", ";", "const", "enum", "processor_type", "processor", ";", "const", "enum", "processor_flags", "flags", ";", "}", "const", "processor_alias_table", "[", "]", "=", "{", "{", "\"g5\"", ",", "PROCESSOR_9672_G5", ",", "PF_IEEE_FLOAT", "}", ",", "{", "\"g6\"", ",", "PROCESSOR_9672_G6", ",", "PF_IEEE_FLOAT", "}", ",", "{", "\"z900\"", ",", "PROCESSOR_2064_Z900", ",", "PF_IEEE_FLOAT", "|", "PF_ZARCH", "}", ",", "{", "\"z990\"", ",", "PROCESSOR_2084_Z990", ",", "PF_IEEE_FLOAT", "|", "PF_ZARCH", "|", "PF_LONG_DISPLACEMENT", "}", ",", "{", "\"z9-109\"", ",", "PROCESSOR_2094_Z9_109", ",", "PF_IEEE_FLOAT", "|", "PF_ZARCH", "|", "PF_LONG_DISPLACEMENT", "|", "PF_EXTIMM", "}", ",", "}", ";", "size_t", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "processor_alias_table", ")", ";", "i", "++", ")", "if", "(", "strcmp", "(", "arg", ",", "processor_alias_table", "[", "i", "]", ".", "name", ")", "==", "0", ")", "{", "*", "type", "=", "processor_alias_table", "[", "i", "]", ".", "processor", ";", "*", "flags", "=", "processor_alias_table", "[", "i", "]", ".", "flags", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "ARG", "is", "the", "name", "of", "a", "processor", ".", "Set", "*", "TYPE", "and", "*", "FLAGS", "to", "the", "associated", "processor_type", "and", "processor_flags", "if", "so", "." ]

[ "s390", "\"g5\"", "\"g6\"", "\"z900\"", "\"z990\"", "\"z9-109\"", "0", "0" ]

[]

[ "<s>", "bool", "rs6000_pragma_target_parse", "(", "tree", "args", ",", "tree", "pop_target", ")", "{", "tree", "prev_tree", "=", "build_target_option_node", "(", "&", "global_options", ")", ";", "tree", "cur_tree", ";", "struct", "cl_target_option", "*", "prev_opt", ",", "*", "cur_opt", ";", "HOST_WIDE_INT", "prev_flags", ",", "cur_flags", ",", "diff_flags", ";", "HOST_WIDE_INT", "prev_bumask", ",", "cur_bumask", ",", "diff_bumask", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n==================== rs6000_pragma_target_parse\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"args:\"", ")", ";", "rs6000_debug_target_options", "(", "args", ",", "\" \"", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "pop_target", ")", "{", "fprintf", "(", "stderr", ",", "\"pop_target:\\n\"", ")", ";", "debug_tree", "(", "pop_target", ")", ";", "}", "else", "fprintf", "(", "stderr", ",", "\"pop_target: <NULL>\\n\"", ")", ";", "fprintf", "(", "stderr", ",", "\"--------------------\\n\"", ")", ";", "}", "if", "(", "!", "args", ")", "{", "cur_tree", "=", "(", "(", "pop_target", ")", "?", "pop_target", ":", "target_option_default_node", ")", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ")", ";", "}", "else", "{", "rs6000_cpu_index", "=", "rs6000_tune_index", "=", "-", "1", ";", "if", "(", "!", "rs6000_inner_target_options", "(", "args", ",", "false", ")", "||", "!", "rs6000_option_override_internal", "(", "false", ")", "||", "(", "cur_tree", "=", "build_target_option_node", "(", "&", "global_options", ")", ")", "==", "NULL_TREE", ")", "{", "if", "(", "TARGET_DEBUG_BUILTIN", "||", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"invalid pragma\\n\"", ")", ";", "return", "false", ";", "}", "}", "target_option_current_node", "=", "cur_tree", ";", "if", "(", "rs6000_target_modify_macros_ptr", ")", "{", "prev_opt", "=", "TREE_TARGET_OPTION", "(", "prev_tree", ")", ";", "prev_bumask", "=", "prev_opt", "->", "x_rs6000_builtin_mask", ";", "prev_flags", "=", "prev_opt", "->", "x_rs6000_isa_flags", ";", "cur_opt", "=", "TREE_TARGET_OPTION", "(", "cur_tree", ")", ";", "cur_flags", "=", "cur_opt", "->", "x_rs6000_isa_flags", ";", "cur_bumask", "=", "cur_opt", "->", "x_rs6000_builtin_mask", ";", "diff_bumask", "=", "(", "prev_bumask", "^", "cur_bumask", ")", ";", "diff_flags", "=", "(", "prev_flags", "^", "cur_flags", ")", ";", "if", "(", "(", "diff_flags", "!=", "0", ")", "||", "(", "diff_bumask", "!=", "0", ")", ")", "{", "rs6000_target_modify_macros_ptr", "(", "false", ",", "prev_flags", "&", "diff_flags", ",", "prev_bumask", "&", "diff_bumask", ")", ";", "rs6000_target_modify_macros_ptr", "(", "true", ",", "cur_flags", "&", "diff_flags", ",", "cur_bumask", "&", "diff_bumask", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "the", "current", "#", "pragma", "GCC", "target", "and", "set", "the", "state", ",", "and", "update", "the", "macros", "based", "on", "what", "was", "changed", ".", "If", "ARGS", "is", "NULL", ",", "then", "POP_TARGET", "is", "used", "to", "reset", "the", "options", "." ]

[ "rs6000", "\"\\n==================== rs6000_pragma_target_parse\\n\"", "\"args:\"", "\" \"", "\"\\n\"", "\"pop_target:\\n\"", "\"pop_target: <NULL>\\n\"", "\"--------------------\\n\"", "1", "\"invalid pragma\\n\"", "0", "0" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", ".", "clear", "(", ")", ";", "MI", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "while", "(", "Result", "==", "Success", "&&", "Complete", "==", "false", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "os", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "return", "Result", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "Hexagon::BUNDLE", "0" ]

[]

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

[ "Get", "a", "const_iterator", "to", "the", "end", "of", "the", "symbol", "table", "." ]

[ "ARM" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "return", "Size", "<=", "128", "?", "AtomicExpansionKind", "::", "LLSC", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "rtx", "visium_eh_return_handler_rtx", "(", "void", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "4", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "1", ";", "return", "mem", ";", "}", "</s>" ]

[ "Helper", "function", "for", "EH_RETURN_HANDLER_RTX", ".", "Return", "the", "RTX", "representing", "a", "location", "in", "which", "to", "store", "the", "address", "of", "an", "exception", "handler", "to", "which", "we", "should", "return", "." ]

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

[]

[ "<s>", "static", "void", "ignore_all_aliases", "(", "HARD_REG_SET", "*", "unavailable", ",", "machine_mode", "mode", ",", "unsigned", "reg", ")", "{", "add_to_hard_reg_set", "(", "unavailable", ",", "mode", ",", "reg", ")", ";", "add_to_hard_reg_set", "(", "unavailable", ",", "mode", ",", "reg", "+", "16", ")", ";", "add_to_hard_reg_set", "(", "unavailable", ",", "mode", ",", "reg", "+", "32", ")", ";", "add_to_hard_reg_set", "(", "unavailable", ",", "mode", ",", "reg", "+", "48", ")", ";", "}", "</s>" ]

[ "Add", "all", "aliases", "of", "the", "register", "to", "the", "unavailable", "register", "set", ".", "REG", "is", "the", "smallest", "register", "number", "that", "can", "then", "be", "used", "to", "reference", "its", "aliases", ".", "UNAVAILABLE", "is", "the", "hard", "register", "set", "to", "add", "the", "ignored", "register", "numbers", "to", "and", "MODE", "is", "the", "mode", "in", "which", "the", "registers", "would", "have", "been", "used", "." ]

[ "aarch64", "16", "32", "48" ]

[]

[ "<s>", "bool", "VETargetLowering", "::", "hasAndNot", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Y", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "a", "bitwise", "and-not", "operation", ":", "X", "=", "~A", "&", "B", "This", "can", "be", "used", "to", "simplify", "select", "or", "other", "instructions", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "if", "(", "SubIdx", "&&", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "{", "DestReg", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "SubIdx", ")", ";", "SubIdx", "=", "0", ";", "}", "bool", "Clone", "=", "true", ";", "unsigned", "Opc", "=", "Orig", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8r0", ":", "case", "X86", "::", "MOV16r0", ":", "case", "X86", "::", "MOV32r0", ":", "case", "X86", "::", "MOV64r0", ":", "{", "if", "(", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "MOV8r0", ":", "Opc", "=", "X86", "::", "MOV8ri", ";", "break", ";", "case", "X86", "::", "MOV16r0", ":", "Opc", "=", "X86", "::", "MOV16ri", ";", "break", ";", "case", "X86", "::", "MOV32r0", ":", "Opc", "=", "X86", "::", "MOV32ri", ";", "break", ";", "case", "X86", "::", "MOV64r0", ":", "Opc", "=", "X86", "::", "MOV64ri64i32", ";", "break", ";", "}", "Clone", "=", "false", ";", "}", "break", ";", "}", "}", "if", "(", "Clone", ")", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestReg", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ";", "}", "MachineInstr", "*", "NewMI", "=", "prior", "(", "I", ")", ";", "NewMI", "->", "getOperand", "(", "0", ")", ".", "setSubReg", "(", "SubIdx", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "0", "X86::MOV8r0", "X86::MOV16r0", "X86::MOV32r0", "X86::MOV64r0", "X86::MOV8r0", "X86::MOV8ri", "X86::MOV16r0", "X86::MOV16ri", "X86::MOV32r0", "X86::MOV32ri", "X86::MOV64r0", "X86::MOV64ri64i32", "0", "0", "0" ]

[]

[ "<s>", "void", "Tile64RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Tile64" ]

[]

[ "<s>", "void", "UnwindOpcodeAssembler", "::", "EmitSPOffset", "(", "int64_t", "Offset", ")", "{", "if", "(", "Offset", ">", "0x200", ")", "{", "uint8_t", "Buff", "[", "16", "]", ";", "Buff", "[", "0", "]", "=", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_INC_VSP_ULEB128", ";", "size_t", "ULEBSize", "=", "encodeULEB128", "(", "(", "Offset", "-", "0x204", ")", ">>", "2", ",", "Buff", "+", "1", ")", ";", "EmitBytes", "(", "Buff", ",", "ULEBSize", "+", "1", ")", ";", "}", "else", "if", "(", "Offset", ">", "0", ")", "{", "if", "(", "Offset", ">", "0x100", ")", "{", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_INC_VSP", "|", "0x3fu", ")", ";", "Offset", "-=", "0x100", ";", "}", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_INC_VSP", "|", "static_cast", "<", "uint8_t", ">", "(", "(", "Offset", "-", "4", ")", ">>", "2", ")", ")", ";", "}", "else", "if", "(", "Offset", "<", "0", ")", "{", "while", "(", "Offset", "<", "-", "0x100", ")", "{", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_DEC_VSP", "|", "0x3fu", ")", ";", "Offset", "+=", "0x100", ";", "}", "EmitInt8", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_DEC_VSP", "|", "static_cast", "<", "uint8_t", ">", "(", "(", "(", "-", "Offset", ")", "-", "4", ")", ">>", "2", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "unwind", "opcodes", "to", "add", "$", "sp", "with", "an", "offset", "." ]

[ "ARM", "0x200", "16", "0", "ARM::EHABI", "0x204", "2", "1", "1", "0", "0x100", "ARM::EHABI", "0x3fu", "0x100", "ARM::EHABI", "4", "2", "0", "0x100", "ARM::EHABI", "0x3fu", "0x100", "ARM::EHABI", "4", "2" ]

[]

[ "<s>", "static", "bool", "s390_is_longrunning", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "insn", "==", "NULL_RTX", ")", "return", "false", ";", "return", "s390_is_fxd", "(", "insn", ")", "||", "s390_is_fpd", "(", "insn", ")", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "INSN", "is", "a", "long-running", "instruction", "." ]

[ "s390" ]

[]

[ "<s>", "static", "enum", "riscv_privilege_levels", "riscv_get_interrupt_type", "(", "tree", "decl", ")", "{", "gcc_assert", "(", "decl", "!=", "NULL_TREE", ")", ";", "if", "(", "(", "TREE_CODE", "(", "decl", ")", "!=", "FUNCTION_DECL", ")", "||", "(", "!", "riscv_interrupt_type_p", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ")", "return", "UNKNOWN_MODE", ";", "tree", "attr_args", "=", "TREE_VALUE", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ")", ";", "if", "(", "attr_args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "attr_args", ")", ")", "!=", "VOID_TYPE", ")", "{", "const", "char", "*", "string", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "attr_args", ")", ")", ";", "if", "(", "!", "strcmp", "(", "string", ",", "\"user\"", ")", ")", "return", "USER_MODE", ";", "else", "if", "(", "!", "strcmp", "(", "string", ",", "\"supervisor\"", ")", ")", "return", "SUPERVISOR_MODE", ";", "else", "return", "MACHINE_MODE", ";", "}", "else", "return", "MACHINE_MODE", ";", "}", "</s>" ]

[ "Get", "the", "interrupt", "type", ",", "return", "UNKNOWN_MODE", "if", "it", "'s", "not", "interrupt", "function", "." ]

[ "riscv", "\"interrupt\"", "\"user\"", "\"supervisor\"" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "const", "MachineOperand", "&", "BaseOp1", ",", "const", "MachineOperand", "&", "BaseOp2", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "!", "memOpsHaveSameBasePtr", "(", "FirstLdSt", ",", "BaseOp1", ",", "SecondLdSt", ",", "BaseOp2", ")", ")", "return", "false", ";", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "(", "isMUBUF", "(", "FirstLdSt", ")", "&&", "isMUBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "FirstLdSt", ")", "&&", "isMTBUF", "(", "SecondLdSt", ")", ")", "||", "(", "isFLAT", "(", "FirstLdSt", ")", "&&", "isFLAT", "(", "SecondLdSt", ")", ")", ")", "{", "const", "unsigned", "MaxGlobalLoadCluster", "=", "6", ";", "if", "(", "NumLoads", ">", "MaxGlobalLoadCluster", ")", "return", "false", ";", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "!", "FirstDst", ")", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "if", "(", "!", "SecondDst", ")", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "else", "if", "(", "isSMRD", "(", "FirstLdSt", ")", "&&", "isSMRD", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "else", "if", "(", "isDS", "(", "FirstLdSt", ")", "&&", "isDS", "(", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "unsigned", "Reg", "=", "FirstDst", "->", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", "?", "MRI", ".", "getRegClass", "(", "Reg", ")", ":", "RI", ".", "getPhysRegClass", "(", "Reg", ")", ";", "return", "(", "NumLoads", "*", "(", "RI", ".", "getRegSizeInBits", "(", "*", "DstRC", ")", "/", "8", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "6", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16", "8" ]

[]

[ "<s>", "bool", "AlphaAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", ")", "return", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "!", "MO", ".", "isImplicit", "(", ")", ")", "RegDefs", ".", "insert", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "assert", "(", "TII", "->", "mayBeNewStore", "(", "*", "MI", ")", "&&", "\"Expecting .new store\"", ")", ";", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "assert", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", ";", "Resources", "->", "reserveResources", "(", "*", "NewMI", ")", ";", "MF", "->", "DeleteMachineInstr", "(", "NewMI", ")", ";", "}", "else", "Resources", "->", "reserveResources", "(", "*", "MI", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Add instruction \"", "<<", "*", "MI", ")", ";", "if", "(", "TII", "->", "mayBeCurLoad", "(", "*", "MI", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "S", ".", "getSUnit", "(", ")", "->", "NumPredsLeft", "==", "1", ")", "{", "UsesDotCur", "=", "S", ".", "getSUnit", "(", ")", ";", "DotCurPNum", "=", "PacketNum", ";", "break", ";", "}", "if", "(", "SU", "==", "UsesDotCur", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "UsesLoad", "=", "MI", "->", "mayLoad", "(", ")", ";", "if", "(", "TII", "->", "isHVXVec", "(", "*", "MI", ")", "&&", "!", "MI", "->", "mayLoad", "(", ")", "&&", "!", "MI", "->", "mayStore", "(", ")", ")", "for", "(", "auto", "&", "S", ":", "SU", "->", "Succs", ")", "if", "(", "S", ".", "isAssignedRegDep", "(", ")", "&&", "S", ".", "getLatency", "(", ")", "==", "0", "&&", "TII", "->", "mayBeNewStore", "(", "*", "S", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ")", "&&", "Resources", "->", "canReserveResources", "(", "*", "S", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ")", ")", "{", "PrefVectorStoreNew", "=", "S", ".", "getSUnit", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Expecting .new store\"", "\" Add instruction \"", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "VRegMapping", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "MachineBasicBlock", "*", "Tile64TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Unexpected instr type to insert!\"", ")", ";", "case", "T64", "::", "SELECT", ":", "return", "EmitSELECTWithCustomInserter", "(", "MI", ",", "MBB", ")", ";", "case", "T64", "::", "STORE_FP", ":", "return", "EmitSTORE_FPWithCustomInserter", "(", "MI", ",", "MBB", ")", ";", "}", "}", "</s>" ]

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

[ "Tile64", "0", "\"Unexpected instr type to insert!\"", "T64::SELECT", "T64::STORE_FP" ]

[]

[ "<s>", "bool", "fp_zero_operand", "(", "rtx", "op", ")", "{", "REAL_VALUE_TYPE", "r", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "SFmode", ")", "return", "false", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "op", ")", ";", "return", "REAL_VALUES_EQUAL", "(", "r", ",", "dconst0", ")", "&&", "!", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "OP", "is", "a", "floating", "point", "value", "with", "value", "0.0", "." ]

[ "sh" ]

[]

[ "<s>", "bool", "SPIRVCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ",", "Register", "SwiftErrorVReg", ")", "const", "{", "if", "(", "VRegs", ".", "size", "(", ")", ">", "1", ")", "return", "false", ";", "if", "(", "Val", ")", "return", "MIRBuilder", ".", "buildInstr", "(", "SPIRV", "::", "OpReturnValue", ")", ".", "addUse", "(", "VRegs", "[", "0", "]", ")", ".", "constrainAllUses", "(", "MIRBuilder", ".", "getTII", "(", ")", ",", "*", "ST", ".", "getRegisterInfo", "(", ")", ",", "*", "ST", ".", "getRegBankInfo", "(", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "SPIRV", "::", "OpReturn", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "1", "SPIRV::OpReturnValue", "0", "SPIRV::OpReturn" ]

[]

[ "<s>", "bool", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "SPIRV" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "setForcedEncodingSize", "(", "0", ")", ";", "if", "(", "Name", ".", "endswith", "(", "\"_e64\"", ")", ")", "setForcedEncodingSize", "(", "64", ")", ";", "else", "if", "(", "Name", ".", "endswith", "(", "\"_e32\"", ")", ")", "setForcedEncodingSize", "(", "32", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"failed parsing operand.\"", ")", ";", "case", "MatchOperand_NoMatch", ":", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "\"not a valid operand.\"", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "0", "\"_e64\"", "64", "\"_e32\"", "32", "AMDGPU", "AMDGPU", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "int", "legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "SYMBOL_REF_P", "(", "x", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "!", "isInt", "<", "8", ">", "(", "Value", ")", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

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

[]

[ "<s>", "void", "HexagonRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOp", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MB", ".", "getParent", "(", ")", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "auto", "&", "HFI", "=", "*", "HST", ".", "getFrameLowering", "(", ")", ";", "Register", "BP", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "HFI", ".", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "BP", ")", ";", "int", "RealOffset", "=", "Offset", "+", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "getImm", "(", ")", ";", "bool", "IsKill", "=", "false", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Hexagon", "::", "PS_fia", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "MI", ".", "RemoveOperand", "(", "FIOp", "+", "1", ")", ";", "return", ";", "case", "Hexagon", "::", "PS_fi", ":", "MI", ".", "setDesc", "(", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ")", ";", "break", ";", "}", "if", "(", "!", "HII", ".", "isValidOffset", "(", "Opc", ",", "RealOffset", ",", "this", ")", ")", "{", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "Register", "TmpR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MB", ",", "II", ",", "DL", ",", "HII", ".", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "TmpR", ")", ".", "addReg", "(", "BP", ")", ".", "addImm", "(", "RealOffset", ")", ";", "BP", "=", "TmpR", ";", "RealOffset", "=", "0", ";", "IsKill", "=", "true", ";", "}", "MI", ".", "getOperand", "(", "FIOp", ")", ".", "ChangeToRegister", "(", "BP", ",", "false", ",", "false", ",", "IsKill", ")", ";", "MI", ".", "getOperand", "(", "FIOp", "+", "1", ")", ".", "ChangeToImmediate", "(", "RealOffset", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Unexpected\"", "Hexagon", "1", "Hexagon::PS_fia", "Hexagon::A2_addi", "1", "Hexagon::PS_fi", "Hexagon::A2_addi", "Hexagon::IntRegsRegClass", "Hexagon::A2_addi", "0", "1" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", ")", "return", "nullptr", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "assert", "(", "Src0Idx", "!=", "-", "1", "&&", "\"Should always have src0 operand\"", ")", ";", "if", "(", "!", "MI", "->", "getOperand", "(", "Src0Idx", ")", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "(", "Src1Idx", "!=", "-", "1", ")", "&&", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "!", "isOperandLegal", "(", "MI", ",", "Src0Idx", ",", "&", "MI", "->", "getOperand", "(", "Src1Idx", ")", ")", "||", "!", "isOperandLegal", "(", "MI", ",", "Src1Idx", ",", "&", "MI", "->", "getOperand", "(", "Src0Idx", ")", ")", ")", ")", "return", "nullptr", ";", "if", "(", "Src1Idx", "!=", "-", "1", "&&", "!", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "!", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "isImm", "(", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "nullptr", ";", "}", "const", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ";", "const", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "const", "MachineOperand", "*", "Src2Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", ")", ";", "if", "(", "(", "Src0Mods", "&&", "Src0Mods", "->", "getImm", "(", ")", ")", "||", "(", "Src1Mods", "&&", "Src1Mods", "->", "getImm", "(", ")", ")", "||", "(", "Src2Mods", "&&", "Src2Mods", "->", "getImm", "(", ")", ")", ")", "return", "nullptr", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ".", "getSubReg", "(", ")", ";", "MI", "->", "getOperand", "(", "Src0Idx", ")", ".", "ChangeToImmediate", "(", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "getImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "MI", "->", "getOperand", "(", "Src1Idx", ")", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "\"Should always have src0 operand\"", "1", "1" ]

[]

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

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

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

[]

[ "<s>", "static", "unsigned", "int", "pdp11_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "<=", "PC_REGNUM", ")", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "pdp11", "1" ]

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPreSched2", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZPostRewritePass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createSystemZExpandPseudoPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "IfConverterID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "RISCVELFTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GO", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "GVA", "->", "hasSection", "(", ")", ")", "{", "StringRef", "Section", "=", "GVA", "->", "getSection", "(", ")", ";", "if", "(", "Section", "==", "\".sdata\"", "||", "Section", "==", "\".sbss\"", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "(", "(", "GVA", "->", "hasExternalLinkage", "(", ")", "&&", "GVA", "->", "isDeclaration", "(", ")", ")", "||", "GVA", "->", "hasCommonLinkage", "(", ")", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GVA", "->", "getValueType", "(", ")", ";", "if", "(", "!", "Ty", "->", "isSized", "(", ")", ")", "return", "false", ";", "return", "isInSmallSection", "(", "GVA", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "global", "address", "should", "be", "placed", "into", "small", "data/bss", "section", "." ]

[ "RISCV", "RISCV", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "unsigned", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", "||", "Size", "==", "8", ")", "&&", "\"Unsupported size\"", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "unsigned", "AddrReg", "=", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "pointer", "(", "MPO", ".", "getAddrSpace", "(", ")", ",", "32", ")", ")", ";", "MIRBuilder", ".", "buildFrameIndex", "(", "AddrReg", ",", "FI", ")", ";", "return", "AddrReg", ";", "}", "</s>" ]

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

[ "ARM", "1", "2", "4", "8", "\"Unsupported size\"", "32" ]

[]

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

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

[ "NVPTX" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "assert", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIdx", ")", ">=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "&&", "\"Stack slot too small for store\"", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getStoreRegOpcode", "(", "SrcReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ",", "FrameIdx", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Stack slot too small for store\"", "16" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isUsedByReturnOnly", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Chain", ")", "const", "{", "if", "(", "N", "->", "getNumValues", "(", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "!", "N", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "SDValue", "TCChain", "=", "Chain", ";", "SDNode", "*", "Copy", "=", "*", "N", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "CopyToReg", ")", "{", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ARMISD", "::", "VMOVRRD", ")", "{", "SDNode", "*", "VMov", "=", "Copy", ";", "SmallPtrSet", "<", "SDNode", "*", ",", "2", ">", "Copies", ";", "for", "(", "SDNode", "*", "U", ":", "VMov", "->", "uses", "(", ")", ")", "{", "if", "(", "U", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", ")", "return", "false", ";", "Copies", ".", "insert", "(", "U", ")", ";", "}", "if", "(", "Copies", ".", "size", "(", ")", ">", "2", ")", "return", "false", ";", "for", "(", "SDNode", "*", "U", ":", "VMov", "->", "uses", "(", ")", ")", "{", "SDValue", "UseChain", "=", "U", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Copies", ".", "count", "(", "UseChain", ".", "getNode", "(", ")", ")", ")", "Copy", "=", "U", ";", "else", "{", "if", "(", "U", "->", "getOperand", "(", "U", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "UseChain", ";", "}", "}", "}", "else", "if", "(", "Copy", "->", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "{", "if", "(", "!", "Copy", "->", "hasOneUse", "(", ")", ")", "return", "false", ";", "Copy", "=", "*", "Copy", "->", "use_begin", "(", ")", ";", "if", "(", "Copy", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "CopyToReg", "||", "!", "Copy", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", ")", "return", "false", ";", "if", "(", "Copy", "->", "getOperand", "(", "Copy", "->", "getNumOperands", "(", ")", "-", "1", ")", ".", "getValueType", "(", ")", "==", "MVT", "::", "Glue", ")", "return", "false", ";", "TCChain", "=", "Copy", "->", "getOperand", "(", "0", ")", ";", "}", "else", "{", "return", "false", ";", "}", "bool", "HasRet", "=", "false", ";", "for", "(", "const", "SDNode", "*", "U", ":", "Copy", "->", "uses", "(", ")", ")", "{", "if", "(", "U", "->", "getOpcode", "(", ")", "!=", "ARMISD", "::", "RET_FLAG", "&&", "U", "->", "getOpcode", "(", ")", "!=", "ARMISD", "::", "INTRET_FLAG", ")", "return", "false", ";", "HasRet", "=", "true", ";", "}", "if", "(", "!", "HasRet", ")", "return", "false", ";", "Chain", "=", "TCChain", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "result", "of", "the", "specified", "node", "is", "used", "by", "a", "return", "node", "only", "." ]

[ "ARM", "ARM", "1", "1", "0", "ISD::CopyToReg", "1", "MVT::Glue", "0", "ARMISD::VMOVRRD", "2", "ISD::CopyToReg", "2", "0", "1", "MVT::Glue", "ISD::BITCAST", "ISD::CopyToReg", "1", "0", "1", "MVT::Glue", "0", "ARMISD::RET_FLAG", "ARMISD::INTRET_FLAG" ]

[]

[ "<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", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "8", ">", "LocalIns", ";", "getOriginalFunctionArgs", "(", "DAG", ",", "MF", ".", "getFunction", "(", ")", ",", "Ins", ",", "LocalIns", ")", ";", "AnalyzeFormalArguments", "(", "CCInfo", ",", "LocalIns", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "const", "ISD", "::", "InputArg", "&", "In", "=", "Ins", "[", "i", "]", ";", "EVT", "VT", "=", "In", ".", "VT", ";", "EVT", "MemVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isVector", "(", ")", "&&", "MemVT", ".", "isVector", "(", ")", ")", "{", "MemVT", "=", "MemVT", ".", "getVectorElementType", "(", ")", ";", "}", "if", "(", "MFI", "->", "getShaderType", "(", ")", "!=", "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", ")", ";", "ISD", "::", "LoadExtType", "Ext", "=", "ISD", "::", "NON_EXTLOAD", ";", "if", "(", "MemVT", ".", "getScalarSizeInBits", "(", ")", "!=", "VT", ".", "getScalarSizeInBits", "(", ")", ")", "{", "Ext", "=", "ISD", "::", "SEXTLOAD", ";", "}", "unsigned", "ValBase", "=", "ArgLocs", "[", "In", ".", "OrigArgIndex", "]", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "PartOffset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "unsigned", "Offset", "=", "36", "+", "VA", ".", "getLocMemOffset", "(", ")", ";", "MachinePointerInfo", "PtrInfo", "(", "UndefValue", "::", "get", "(", "PtrTy", ")", ",", "PartOffset", "-", "ValBase", ")", ";", "SDValue", "Arg", "=", "DAG", ".", "getLoad", "(", "ISD", "::", "UNINDEXED", ",", "Ext", ",", "VT", ",", "DL", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "Offset", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "i32", ")", ",", "PtrInfo", ",", "MemVT", ",", "false", ",", "true", ",", "true", ",", "4", ")", ";", "InVals", ".", "push_back", "(", "Arg", ")", ";", "MFI", "->", "ABIArgOffset", "=", "Offset", "+", "MemVT", ".", "getStoreSize", "(", ")", ";", "}", "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", "ISD::InputArg", "AMDGPUAS::CONSTANT_BUFFER_0", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::SEXTLOAD", "36", "ISD::UNINDEXED", "MVT::i32", "MVT::i32", "4" ]

[]

[ "<s>", "BitVector", "HexagonRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "VTMP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GELR", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GSR", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GOSP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "G3", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "P3_0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UGP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UPCYCLELO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UPCYCLEHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "FRAMELIMIT", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "FRAMEKEY", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PKTCOUNTLO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PKTCOUNTHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UTIMERLO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UTIMERHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "C8", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR_OVF", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "hasReservedR19", "(", ")", ")", "Reserved", ".", "set", "(", "Hexagon", "::", "R19", ")", ";", "for", "(", "int", "x", "=", "Reserved", ".", "find_first", "(", ")", ";", "x", ">=", "0", ";", "x", "=", "Reserved", ".", "find_next", "(", "x", ")", ")", "markSuperRegs", "(", "Reserved", ",", "x", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::R29", "Hexagon::R30", "Hexagon::R31", "Hexagon::VTMP", "Hexagon::GELR", "Hexagon::GSR", "Hexagon::GOSP", "Hexagon::G3", "Hexagon::SA0", "Hexagon::LC0", "Hexagon::SA1", "Hexagon::LC1", "Hexagon::P3_0", "Hexagon::USR", "Hexagon::PC", "Hexagon::UGP", "Hexagon::GP", "Hexagon::CS0", "Hexagon::CS1", "Hexagon::UPCYCLELO", "Hexagon::UPCYCLEHI", "Hexagon::FRAMELIMIT", "Hexagon::FRAMEKEY", "Hexagon::PKTCOUNTLO", "Hexagon::PKTCOUNTHI", "Hexagon::UTIMERLO", "Hexagon::UTIMERHI", "Hexagon::C8", "Hexagon::USR_OVF", "Hexagon", "Hexagon::R19", "0" ]

[]

[ "<s>", "static", "rtx", "visium_function_value_1", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_FPU", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", "*", "2", ")", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP_RETURN_REGNUM", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "RETURN_REGNUM", ")", ";", "}", "</s>" ]

[ "Define", "how", "scalar", "values", "are", "returned", "." ]

[ "visium", "2" ]

[]

[ "<s>", "const", "char", "*", "output_shift", "(", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "const", "char", "*", "shift_one", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "shift_one", "=", "\"add %0,%1,%1\"", ";", "break", ";", "case", "ASHIFTRT", ":", "shift_one", "=", "\"asr %0,%1\"", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_one", "=", "\"lsr %0,%1\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", "{", "output_asm_insn", "(", "\"and.f lp_count,%2, 0x1f\"", ",", "operands", ")", ";", "goto", "shiftloop", ";", "}", "else", "{", "int", "n", ";", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "n", "=", "n", "&", "0x1f", ";", "if", "(", "code", "==", "ASHIFT", "&&", "n", "<=", "9", "&&", "n", ">", "2", "&&", "dest_reg_operand", "(", "operands", "[", "4", "]", ",", "SImode", ")", ")", "{", "output_asm_insn", "(", "\"mov %4,0\\n\\tadd3 %0,%4,%1\"", ",", "operands", ")", ";", "for", "(", "n", "-=", "3", ";", "n", ">=", "3", ";", "n", "-=", "3", ")", "output_asm_insn", "(", "\"add3 %0,%4,%0\"", ",", "operands", ")", ";", "if", "(", "n", "==", "2", ")", "output_asm_insn", "(", "\"add2 %0,%4,%0\"", ",", "operands", ")", ";", "else", "if", "(", "n", ")", "output_asm_insn", "(", "\"add %0,%0,%0\"", ",", "operands", ")", ";", "}", "else", "if", "(", "n", "<=", "4", ")", "{", "while", "(", "--", "n", ">=", "0", ")", "{", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "operands", "[", "1", "]", "=", "operands", "[", "0", "]", ";", "}", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "1", ")", "{", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "output_asm_insn", "(", "\"and %0,%1,1\\n\\tror %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "ASHIFTRT", ":", "output_asm_insn", "(", "\"add.f 0,%1,%1\\n\\tsbc %0,%0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "output_asm_insn", "(", "\"add.f 0,%1,%1\\n\\trlc %0,0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "2", "&&", "dest_reg_operand", "(", "operands", "[", "4", "]", ",", "SImode", ")", ")", "{", "switch", "(", "code", ")", "{", "case", "ASHIFT", ":", "output_asm_insn", "(", "\"and %0,%1,3\\n\\tror %0,%0\\n\\tror %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "ASHIFTRT", ":", "output_asm_insn", "(", "\"add.f %4,%1,%1\\n\\tsbc %0,%0,%0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add.f %4,%1,%1\\n\\tbxor %0,%4,31\\n\\t\"", "\"sbc.f %0,%0,%4\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "break", ";", "case", "LSHIFTRT", ":", "output_asm_insn", "(", "\"add.f %4,%1,%1\\n\\trlc %0,0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add.f %0,%1,%1\\n\\trlc.f %0,0\\n\\t\"", "\"and %0,%0,1\\n\\trlc %0,%0\"", ",", "operands", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "n", "==", "BITS_PER_WORD", "-", "3", "&&", "code", "==", "ASHIFT", ")", "output_asm_insn", "(", "\"and %0,%1,7\\n\\tror %0,%0\\n\\tror %0,%0\\n\\tror %0,%0\"", ",", "operands", ")", ";", "else", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "n", ")", ";", "output_asm_insn", "(", "\"mov.f lp_count, %2\"", ",", "operands", ")", ";", "shiftloop", ":", "{", "output_asm_insn", "(", "\"lpnz\\t2f\"", ",", "operands", ")", ";", "output_asm_insn", "(", "shift_one", ",", "operands", ")", ";", "output_asm_insn", "(", "\"nop\"", ",", "operands", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"2:\\t%s end single insn loop\\n\"", ",", "ASM_COMMENT_START", ")", ";", "}", "}", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "FIXME", ":", "This", "probably", "can", "be", "done", "using", "a", "define_split", "in", "arc.md", ".", "Alternately", ",", "generate", "rtx", "rather", "than", "output", "instructions", "." ]

[ "arc", "3", "\"add %0,%1,%1\"", "\"asr %0,%1\"", "\"lsr %0,%1\"", "2", "\"and.f lp_count,%2, 0x1f\"", "2", "0x1f", "9", "2", "4", "\"mov %4,0\\n\\tadd3 %0,%4,%1\"", "3", "3", "3", "\"add3 %0,%4,%0\"", "2", "\"add2 %0,%4,%0\"", "\"add %0,%0,%0\"", "4", "0", "1", "0", "1", "\"and %0,%1,1\\n\\tror %0,%0\"", "\"add.f 0,%1,%1\\n\\tsbc %0,%0,%0\"", "\"add.f 0,%1,%1\\n\\trlc %0,0\"", "2", "4", "\"and %0,%1,3\\n\\tror %0,%0\\n\\tror %0,%0\"", "\"add.f %4,%1,%1\\n\\tsbc %0,%0,%0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", "\"add.f %4,%1,%1\\n\\tbxor %0,%4,31\\n\\t\"", "\"sbc.f %0,%0,%4\\n\\trlc %0,%0\"", "\"add.f %4,%1,%1\\n\\trlc %0,0\\n\\t\"", "\"add.f 0,%4,%4\\n\\trlc %0,%0\"", "\"add.f %0,%1,%1\\n\\trlc.f %0,0\\n\\t\"", "\"and %0,%0,1\\n\\trlc %0,%0\"", "3", "\"and %0,%1,7\\n\\tror %0,%0\\n\\tror %0,%0\\n\\tror %0,%0\"", "2", "\"mov.f lp_count, %2\"", "\"lpnz\\t2f\"", "\"nop\"", "\"2:\\t%s end single insn loop\\n\"", "\"\"" ]

[]

[ "<s>", "int", "frv_emit_scc", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "set", ";", "rtx", "test_rtx", ";", "rtx", "clobber", ";", "rtx", "cr_reg", ";", "enum", "rtx_code", "test", "=", "GET_CODE", "(", "operands", "[", "1", "]", ")", ";", "rtx", "cc_reg", "=", "frv_emit_comparison", "(", "test", ",", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "test_rtx", "=", "gen_rtx_fmt_ee", "(", "test", ",", "SImode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "set", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "operands", "[", "0", "]", ",", "test_rtx", ")", ";", "cr_reg", "=", "(", "(", "TARGET_ALLOC_CC", ")", "?", "gen_reg_rtx", "(", "CC_CCRmode", ")", ":", "gen_rtx_REG", "(", "CC_CCRmode", ",", "(", "(", "GET_MODE", "(", "cc_reg", ")", "==", "CC_FPmode", ")", "?", "FCR_FIRST", ":", "ICR_FIRST", ")", ")", ")", ";", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "cr_reg", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "set", ",", "clobber", ")", ")", ")", ";", "return", "TRUE", ";", "}", "</s>" ]

[ "Emit", "code", "to", "set", "a", "gpr", "to", "1/0", "based", "on", "a", "comparison", ".", "The", "comparison", "operands", "were", "previously", "stored", "in", "frv_compare_op0", "and", "frv_compare_op1", "." ]

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

[]

[ "<s>", "void", "emitDwarfLocDirective", "(", "unsigned", "FileNo", ",", "unsigned", "Line", ",", "unsigned", "Column", ",", "unsigned", "Flags", ",", "unsigned", "Isa", ",", "unsigned", "Discriminator", ",", "StringRef", "FileName", ")", "override", "{", "}", "</s>" ]

[ "This", "implements", "the", "DWARF2", "'.loc", "fileno", "lineno", "...", "'", "assembler", "directive", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "&", "MF", "->", "front", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", "||", "Reg", "==", "Mips", "::", "RA_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::RA", "Mips::RA_64" ]

[]

[ "<s>", "int", "m68k_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "m68k_interrupt_function_p", "(", "current_function_decl", ")", "&&", "!", "regs_ever_live", "[", "new_reg", "]", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "old_reg", "can", "be", "renamed", "to", "register", "new_reg", "." ]

[ "m68k", "0", "1" ]

[]

[ "<s>", "bool", "aarch64_expand_movmem", "(", "rtx", "*", "operands", ")", "{", "unsigned", "int", "n", ";", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "base", ";", "bool", "speed_p", "=", "!", "optimize_function_for_size_p", "(", "cfun", ")", ";", "unsigned", "int", "max_instructions", "=", "(", "speed_p", "?", "15", ":", "AARCH64_CALL_RATIO", ")", "/", "2", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "n", "=", "UINTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "(", "(", "n", "/", "16", ")", "+", "(", "n", "%", "16", "?", "2", ":", "0", ")", ")", ">", "max_instructions", ")", "return", "false", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "dst", ",", "0", ")", ")", ";", "dst", "=", "adjust_automodify_address", "(", "dst", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "src", "=", "adjust_automodify_address", "(", "src", ",", "VOIDmode", ",", "base", ",", "0", ")", ";", "if", "(", "n", "<", "4", ")", "{", "if", "(", "n", ">=", "2", ")", "{", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "HImode", ")", ";", "n", "-=", "2", ";", "}", "if", "(", "n", "==", "1", ")", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "QImode", ")", ";", "return", "true", ";", "}", "if", "(", "n", "<", "8", ")", "{", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "SImode", ")", ";", "n", "-=", "4", ";", "if", "(", "n", ">", "0", ")", "{", "int", "move", "=", "n", "-", "4", ";", "src", "=", "aarch64_move_pointer", "(", "src", ",", "move", ")", ";", "dst", "=", "aarch64_move_pointer", "(", "dst", ",", "move", ")", ";", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "SImode", ")", ";", "}", "return", "true", ";", "}", "while", "(", "n", ">=", "8", ")", "{", "if", "(", "n", "/", "16", ")", "{", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "TImode", ")", ";", "n", "-=", "16", ";", "}", "else", "{", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "DImode", ")", ";", "n", "-=", "8", ";", "}", "}", "if", "(", "n", "==", "0", ")", "return", "true", ";", "else", "if", "(", "n", "==", "1", ")", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "QImode", ")", ";", "else", "if", "(", "n", "==", "2", ")", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "HImode", ")", ";", "else", "if", "(", "n", "==", "4", ")", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "SImode", ")", ";", "else", "{", "if", "(", "n", "==", "3", ")", "{", "src", "=", "aarch64_move_pointer", "(", "src", ",", "-", "1", ")", ";", "dst", "=", "aarch64_move_pointer", "(", "dst", ",", "-", "1", ")", ";", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "SImode", ")", ";", "}", "else", "{", "int", "move", "=", "n", "-", "8", ";", "src", "=", "aarch64_move_pointer", "(", "src", ",", "move", ")", ";", "dst", "=", "aarch64_move_pointer", "(", "dst", ",", "move", ")", ";", "aarch64_copy_one_block_and_progress_pointers", "(", "&", "src", ",", "&", "dst", ",", "DImode", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "movmem", ",", "as", "if", "from", "a", "__builtin_memcpy", ".", "Return", "true", "if", "we", "succeed", ",", "otherwise", "return", "false", "." ]

[ "aarch64", "0", "1", "15", "2", "2", "2", "16", "16", "2", "0", "0", "0", "0", "0", "4", "2", "2", "1", "8", "4", "0", "4", "8", "16", "16", "8", "0", "1", "2", "4", "3", "1", "1", "8" ]

[]

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

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

[ "tilepro", "0", "4", "0", "4" ]

[]

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

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "return", "ScalarizeVectorLoad", "(", "Op", ",", "DAG", ")", ";", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "PtrVT", "=", "BasePtr", ".", "getValueType", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "MachinePointerInfo", "SrcValue", "(", "Load", "->", "getMemOperand", "(", ")", "->", "getValue", "(", ")", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "VT", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "DAG", ".", "GetSplitDestVTs", "(", "MemVT", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "DAG", ".", "SplitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "Load", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "SL", ",", "PtrVT", ",", "BasePtr", ",", "DAG", ".", "getConstant", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ",", "SL", ",", "PtrVT", ")", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "Load", "->", "isVolatile", "(", ")", ",", "Load", "->", "isNonTemporal", "(", ")", ",", "Load", "->", "isInvariant", "(", ")", ",", "Load", "->", "getAlignment", "(", ")", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "ISD::ADD", "ISD::CONCAT_VECTORS", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "ARM_PREALLOC_LOAD_STORE_OPT_NAME", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "c6x_function_end", "(", "FILE", "*", "file", ",", "const", "char", "*", "fname", ")", "{", "c6x_output_fn_unwind", "(", "file", ")", ";", "insn_info", ".", "release", "(", ")", ";", "if", "(", "!", "flag_inhibit_size_directive", ")", "ASM_OUTPUT_MEASURED_SIZE", "(", "file", ",", "fname", ")", ";", "}", "</s>" ]

[ "Called", "when", "a", "function", "has", "been", "assembled", ".", "It", "should", "perform", "all", "the", "tasks", "of", "ASM_DECLARE_FUNCTION_SIZE", "in", "elfos.h", ",", "plus", "target-specific", "tasks", ".", "We", "free", "the", "reservation", "(", "and", "other", "scheduling", ")", "information", "here", "now", "that", "all", "insns", "have", "been", "output", "." ]

[ "c6x" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "AVRTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "LD8loRegClass", ")", ";", "case", "'b'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "PTRDISPREGSRegClass", ")", ";", "case", "'d'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "LD8RegClass", ")", ";", "case", "'l'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPR8loRegClass", ")", ";", "case", "'e'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'q'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPRSPRegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "GPR8RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "DREGSRegClass", ")", ";", "case", "'t'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R0", ")", ",", "&", "AVR", "::", "GPR8RegClass", ")", ";", "case", "'w'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "AVR", "::", "IWREGSRegClass", ")", ";", "case", "'x'", ":", "case", "'X'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R27R26", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'y'", ":", "case", "'Y'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R29R28", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "case", "'z'", ":", "case", "'Z'", ":", "return", "std", "::", "make_pair", "(", "unsigned", "(", "AVR", "::", "R31R30", ")", ",", "&", "AVR", "::", "PTRREGSRegClass", ")", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Subtarget", ".", "getRegisterInfo", "(", ")", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "1", "0", "0U", "AVR::LD8loRegClass", "0U", "AVR::PTRDISPREGSRegClass", "0U", "AVR::LD8RegClass", "0U", "AVR::GPR8loRegClass", "0U", "AVR::PTRREGSRegClass", "0U", "AVR::GPRSPRegClass", "MVT::i8", "0U", "AVR::GPR8RegClass", "0U", "AVR::DREGSRegClass", "AVR::R0", "AVR::GPR8RegClass", "0U", "AVR::IWREGSRegClass", "AVR::R27R26", "AVR::PTRREGSRegClass", "AVR::R29R28", "AVR::PTRREGSRegClass", "AVR::R31R30", "AVR::PTRREGSRegClass" ]

[]

[ "<s>", "bool", "riscv_hard_regno_rename_ok", "(", "unsigned", "from_regno", "ATTRIBUTE_UNUSED", ",", "unsigned", "to_regno", ")", "{", "return", "!", "cfun", "->", "machine", "->", "interrupt_handler_p", "||", "df_regs_ever_live_p", "(", "to_regno", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "FROM_REGNO", "can", "be", "renamed", "to", "register", "TO_REGNO", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "if", "(", "CommentStream", ")", "{", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "expand_interrupt_handler_prologue", "(", "rtx", "spreg", ",", "e_funkind", "fkind", ",", "bool", "all", ")", "{", "HOST_WIDE_INT", "frame_size", "=", "get_frame_size", "(", ")", ";", "rtx", "predec1", "=", "gen_rtx_PRE_DEC", "(", "SImode", ",", "spreg", ")", ";", "rtx", "predec", "=", "gen_rtx_MEM", "(", "SImode", ",", "predec1", ")", ";", "rtx_insn", "*", "insn", ";", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "tree", "kspisusp", "=", "lookup_attribute", "(", "\"kspisusp\"", ",", "attrs", ")", ";", "if", "(", "kspisusp", ")", "{", "insn", "=", "emit_move_insn", "(", "spreg", ",", "gen_rtx_REG", "(", "Pmode", ",", "REG_USP", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "fkind", "==", "EXCPT_HANDLER", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "spreg", ",", "spreg", ",", "GEN_INT", "(", "-", "12", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "!", "crtl", "->", "is_leaf", ")", "all", "=", "true", ";", "expand_prologue_reg_save", "(", "spreg", ",", "all", ",", "true", ")", ";", "if", "(", "ENABLE_WA_05000283", "||", "ENABLE_WA_05000315", ")", "{", "rtx", "chipid", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "0xFFC00014", ",", "SImode", ")", ")", ";", "rtx", "p5reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "REG_P5", ")", ";", "emit_insn", "(", "gen_movbi", "(", "bfin_cc_rtx", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_movsi_high", "(", "p5reg", ",", "chipid", ")", ")", ";", "emit_insn", "(", "gen_movsi_low", "(", "p5reg", ",", "p5reg", ",", "chipid", ")", ")", ";", "emit_insn", "(", "gen_dummy_load", "(", "p5reg", ",", "bfin_cc_rtx", ")", ")", ";", "}", "if", "(", "lookup_attribute", "(", "\"nesting\"", ",", "attrs", ")", ")", "{", "rtx", "srcreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "ret_regs", "[", "fkind", "]", ")", ";", "insn", "=", "emit_move_insn", "(", "predec", ",", "srcreg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "do_link", "(", "spreg", ",", "frame_size", ",", "all", ")", ";", "if", "(", "fkind", "==", "EXCPT_HANDLER", ")", "{", "rtx", "r0reg", "=", "gen_rtx_REG", "(", "SImode", ",", "REG_R0", ")", ";", "rtx", "r1reg", "=", "gen_rtx_REG", "(", "SImode", ",", "REG_R1", ")", ";", "rtx", "r2reg", "=", "gen_rtx_REG", "(", "SImode", ",", "REG_R2", ")", ";", "emit_move_insn", "(", "r0reg", ",", "gen_rtx_REG", "(", "SImode", ",", "REG_SEQSTAT", ")", ")", ";", "emit_insn", "(", "gen_ashrsi3", "(", "r0reg", ",", "r0reg", ",", "GEN_INT", "(", "26", ")", ")", ")", ";", "emit_insn", "(", "gen_ashlsi3", "(", "r0reg", ",", "r0reg", ",", "GEN_INT", "(", "26", ")", ")", ")", ";", "emit_move_insn", "(", "r1reg", ",", "spreg", ")", ";", "emit_move_insn", "(", "r2reg", ",", "gen_rtx_REG", "(", "Pmode", ",", "REG_FP", ")", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "r2reg", ",", "r2reg", ",", "GEN_INT", "(", "8", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Generate", "a", "prologue", "suitable", "for", "a", "function", "of", "kind", "FKIND", ".", "This", "is", "called", "for", "interrupt", "and", "exception", "handler", "prologues", ".", "SPREG", "contains", "(", "reg", ":", "SI", "REG_SP", ")", "." ]

[ "bfin", "\"kspisusp\"", "1", "12", "1", "0xFFC00014", "\"nesting\"", "1", "26", "26", "8" ]

[]

[ "<s>", "static", "void", "epiphany_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "int", "first_anon_arg", ";", "CUMULATIVE_ARGS", "next_cum", ";", "machine_function_t", "*", "mf", "=", "MACHINE_FUNCTION", "(", "cfun", ")", ";", "gcc_assert", "(", "mode", "!=", "BLKmode", ")", ";", "next_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "next_cum", "=", "ROUND_ADVANCE_CUM", "(", "next_cum", ",", "mode", ",", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "mode", ",", "type", ")", ";", "first_anon_arg", "=", "next_cum", ";", "if", "(", "first_anon_arg", "<", "MAX_EPIPHANY_PARM_REGS", "&&", "!", "no_rtl", ")", "{", "int", "first_reg_offset", "=", "first_anon_arg", ";", "*", "pretend_size", "=", "(", "(", "MAX_EPIPHANY_PARM_REGS", "-", "first_reg_offset", ")", "*", "UNITS_PER_WORD", ")", ";", "}", "mf", "->", "args_parsed", "=", "1", ";", "mf", "->", "pretend_args_odd", "=", "(", "(", "*", "pretend_size", "&", "UNITS_PER_WORD", ")", "?", "1", ":", "0", ")", ";", "}", "</s>" ]

[ "Do", "any", "needed", "setup", "for", "a", "variadic", "function", ".", "For", "the", "EPIPHANY", ",", "we", "actually", "emit", "the", "code", "in", "epiphany_expand_prologue", ".", "CUM", "has", "not", "been", "updated", "for", "the", "last", "named", "argument", "which", "has", "type", "TYPE", "and", "mode", "MODE", ",", "and", "we", "rely", "on", "this", "fact", "." ]

[ "epiphany", "1", "1", "0" ]

[]

[ "<s>", "AArch64TargetLowering", "::", "ConstraintType", "AArch64TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'z'", ":", "return", "C_Other", ";", "case", "'x'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'S'", ":", "return", "C_Other", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "AArch64", "AArch64", "AArch64", "1", "0" ]

[]

[ "<s>", "MachineInstr", "*", "PPCInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "RLWIMI", ")", "return", "TargetInstrInfoImpl", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "unsigned", "Reg0", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Reg1", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "bool", "Reg1IsKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "Reg2IsKill", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "isKill", "(", ")", ";", "bool", "ChangeReg0", "=", "false", ";", "if", "(", "Reg0", "==", "Reg1", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getOperandConstraint", "(", "0", ",", "MCOI", "::", "TIED_TO", ")", "&&", "\"Expecting a two-address instruction!\"", ")", ";", "Reg2IsKill", "=", "false", ";", "ChangeReg0", "=", "true", ";", "}", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "unsigned", "ME", "=", "MI", "->", "getOperand", "(", "5", ")", ".", "getImm", "(", ")", ";", "if", "(", "NewMI", ")", "{", "unsigned", "Reg0", "=", "ChangeReg0", "?", "Reg2", ":", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "Reg0IsDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "return", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "MI", "->", "getDesc", "(", ")", ")", ".", "addReg", "(", "Reg0", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "Reg0IsDead", ")", ")", ".", "addReg", "(", "Reg2", ",", "getKillRegState", "(", "Reg2IsKill", ")", ")", ".", "addReg", "(", "Reg1", ",", "getKillRegState", "(", "Reg1IsKill", ")", ")", ".", "addImm", "(", "(", "ME", "+", "1", ")", "&", "31", ")", ".", "addImm", "(", "(", "MB", "-", "1", ")", "&", "31", ")", ";", "}", "if", "(", "ChangeReg0", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "Reg2", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setReg", "(", "Reg1", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "Reg2", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setIsKill", "(", "Reg1IsKill", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "Reg2IsKill", ")", ";", "MI", "->", "getOperand", "(", "4", ")", ".", "setImm", "(", "(", "ME", "+", "1", ")", "&", "31", ")", ";", "MI", "->", "getOperand", "(", "5", ")", ".", "setImm", "(", "(", "MB", "-", "1", ")", "&", "31", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "PowerPC", "PPC", "PPC::RLWIMI", "3", "0", "0", "0", "1", "2", "1", "2", "0", "\"Expecting a two-address instruction!\"", "4", "5", "0", "0", "1", "31", "1", "31", "0", "2", "1", "2", "1", "4", "1", "31", "5", "1", "31" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Texture Intrinsics Replacer\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"R600 Texture Intrinsics Replacer\"" ]

[]

[ "<s>", "unsigned", "AArch64TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "AArch64", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "AArch64", "AArch64", "\"sp\"", "AArch64::SP", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "static", "void", "nds32_interrupt_attribute_parse_string", "(", "const", "char", "*", "original_str", ",", "const", "char", "*", "func_name", ",", "unsigned", "int", "s_level", ")", "{", "char", "target_str", "[", "100", "]", ";", "enum", "nds32_isr_save_reg", "save_reg", ";", "enum", "nds32_isr_nested_type", "nested_type", ";", "char", "*", "save_all_regs_str", ",", "*", "save_caller_regs_str", ";", "char", "*", "nested_str", ",", "*", "not_nested_str", ",", "*", "ready_nested_str", ",", "*", "critical_str", ";", "char", "*", "id_str", ",", "*", "value_str", ";", "strcpy", "(", "target_str", ",", "original_str", ")", ";", "save_all_regs_str", "=", "strstr", "(", "target_str", ",", "\"save_all_regs\"", ")", ";", "save_caller_regs_str", "=", "strstr", "(", "target_str", ",", "\"save_caller_regs\"", ")", ";", "if", "(", "save_all_regs_str", ")", "save_reg", "=", "NDS32_SAVE_ALL", ";", "else", "if", "(", "save_caller_regs_str", ")", "save_reg", "=", "NDS32_PARTIAL_SAVE", ";", "else", "save_reg", "=", "NDS32_PARTIAL_SAVE", ";", "nested_str", "=", "strstr", "(", "target_str", ",", "\"nested\"", ")", ";", "not_nested_str", "=", "strstr", "(", "target_str", ",", "\"not_nested\"", ")", ";", "ready_nested_str", "=", "strstr", "(", "target_str", ",", "\"ready_nested\"", ")", ";", "critical_str", "=", "strstr", "(", "target_str", ",", "\"critical\"", ")", ";", "if", "(", "not_nested_str", ")", "nested_type", "=", "NDS32_NOT_NESTED", ";", "else", "if", "(", "ready_nested_str", ")", "nested_type", "=", "NDS32_NESTED_READY", ";", "else", "if", "(", "nested_str", ")", "nested_type", "=", "NDS32_NESTED", ";", "else", "if", "(", "critical_str", ")", "nested_type", "=", "NDS32_CRITICAL", ";", "else", "nested_type", "=", "NDS32_NOT_NESTED", ";", "id_str", "=", "strstr", "(", "target_str", ",", "\"id=\"", ")", ";", "if", "(", "id_str", "==", "NULL", ")", "error", "(", "\"require id argument in the string\"", ")", ";", "id_str", "=", "strtok", "(", "id_str", ",", "\"=\"", ")", ";", "value_str", "=", "strtok", "(", "NULL", ",", "\";\"", ")", ";", "value_str", "=", "strtok", "(", "value_str", ",", "\",\"", ")", ";", "while", "(", "value_str", "!=", "NULL", ")", "{", "int", "i", ";", "i", "=", "atoi", "(", "value_str", ")", ";", "i", "=", "i", "+", "9", ";", "if", "(", "i", "<", "9", "||", "i", ">", "72", ")", "error", "(", "\"invalid id value for interrupt attribute\"", ")", ";", "nds32_isr_vectors", "[", "i", "]", ".", "category", "=", "NDS32_ISR_INTERRUPT", ";", "strcpy", "(", "nds32_isr_vectors", "[", "i", "]", ".", "func_name", ",", "func_name", ")", ";", "nds32_isr_vectors", "[", "i", "]", ".", "save_reg", "=", "save_reg", ";", "nds32_isr_vectors", "[", "i", "]", ".", "nested_type", "=", "nested_type", ";", "nds32_isr_vectors", "[", "i", "]", ".", "security_level", "=", "s_level", ";", "value_str", "=", "strtok", "(", "NULL", ",", "\",\"", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "FIXME", ":", "FOR", "BACKWARD", "COMPATIBILITY", ",", "we", "need", "to", "support", "following", "patterns", ":", "__attribute__", "(", "(", "interrupt", "(", "``", "XXX", ";", "YYY", ";", "id=ZZZ", "''", ")", ")", ")", "__attribute__", "(", "(", "exception", "(", "``", "XXX", ";", "YYY", ";", "id=ZZZ", "''", ")", ")", ")", "__attribute__", "(", "(", "reset", "(", "``", "vectors=XXX", ";", "nmi_func=YYY", ";", "warm_func=ZZZ", "''", ")", ")", ")", "We", "provide", "several", "functions", "to", "parse", "the", "strings", "." ]

[ "nds32", "100", "\"save_all_regs\"", "\"save_caller_regs\"", "\"nested\"", "\"not_nested\"", "\"ready_nested\"", "\"critical\"", "\"id=\"", "\"require id argument in the string\"", "\"=\"", "\";\"", "\",\"", "9", "9", "72", "\"invalid id value for interrupt attribute\"", "\",\"" ]

[]

[ "<s>", "M680x0Subtarget", "&", "M680x0Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "Triple", "TT", ",", "StringRef", "FS", ",", "const", "M680x0TargetMachine", "&", "TM", ")", "{", "std", "::", "string", "CPUName", "=", "selectM680x0CPU", "(", "TT", ",", "CPU", ")", ";", "IsM68000", "=", "true", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "stackAlignment", "=", "8", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "M680x0", "M680x0", "8" ]

[]