Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "m32c_regno_ok_for_base_p", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "A0_REGNO", "||", "regno", "==", "A1_REGNO", "||", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "REGNO_OK_FOR_BASE_P", "." ]

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

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitInlineAsmEnd", "(", "const", "MCSubtargetInfo", "&", "StartInfo", ",", "const", "MCSubtargetInfo", "*", "EndInfo", ")", "const", "{", "const", "bool", "WasThumb", "=", "isThumb", "(", "StartInfo", ")", ";", "if", "(", "!", "EndInfo", "||", "WasThumb", "!=", "isThumb", "(", "*", "EndInfo", ")", ")", "{", "OutStreamer", "->", "EmitAssemblerFlag", "(", "WasThumb", "?", "MCAF_Code16", ":", "MCAF_Code32", ")", ";", "}", "}", "</s>" ]

[ "Let", "the", "target", "do", "anything", "it", "needs", "to", "do", "after", "emitting", "inlineasm", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "unsigned", "DefaultSafety", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "PPC", "::", "G8RC_NOX0RegClassID", ":", "case", "PPC", "::", "GPRC_NOR0RegClassID", ":", "case", "PPC", "::", "G8RCRegClassID", ":", "case", "PPC", "::", "GPRCRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "32", "-", "FP", "-", "DefaultSafety", ";", "}", "case", "PPC", "::", "F8RCRegClassID", ":", "case", "PPC", "::", "F4RCRegClassID", ":", "case", "PPC", "::", "VRRCRegClassID", ":", "case", "PPC", "::", "VSLRCRegClassID", ":", "case", "PPC", "::", "VSHRCRegClassID", ":", "return", "32", "-", "DefaultSafety", ";", "case", "PPC", "::", "VSRCRegClassID", ":", "return", "64", "-", "DefaultSafety", ";", "case", "PPC", "::", "CRRCRegClassID", ":", "return", "8", "-", "DefaultSafety", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "PowerPC", "PPC", "1", "0", "PPC::G8RC_NOX0RegClassID", "PPC::GPRC_NOR0RegClassID", "PPC::G8RCRegClassID", "PPC::GPRCRegClassID", "1", "0", "32", "PPC::F8RCRegClassID", "PPC::F4RCRegClassID", "PPC::VRRCRegClassID", "PPC::VSLRCRegClassID", "PPC::VSHRCRegClassID", "32", "PPC::VSRCRegClassID", "64", "PPC::CRRCRegClassID", "8" ]

[]

[ "<s>", "int", "X86TargetLowering", "::", "getScalingFactorCost", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "isLegalAddressingMode", "(", "AM", ",", "Ty", ",", "AS", ")", ")", "return", "AM", ".", "Scale", "!=", "0", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "the", "scaling", "factor", "used", "in", "the", "addressing", "mode", "represented", "by", "AM", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "glibc_supports_ieee_128bit", "(", "void", ")", "{", "if", "(", "OPTION_GLIBC", "&&", "!", "BYTES_BIG_ENDIAN", "&&", "(", "(", "TARGET_GLIBC_MAJOR", "*", "1000", ")", "+", "TARGET_GLIBC_MINOR", ")", ">=", "2032", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "are", "using", "GLIBC", ",", "and", "it", "supports", "IEEE", "128-bit", "long", "double", ".", "This", "support", "is", "only", "in", "little", "endian", "GLIBC", "2.32", "or", "newer", "." ]

[ "rs6000", "1000", "2032" ]

[]

[ "<s>", "int", "arc_write_ext_corereg", "(", "rtx", "insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SET", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "break", ";", "default", ":", "continue", ";", "}", "const_rtx", "dest", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", ">=", "32", "&&", "REGNO", "(", "dest", ")", "<", "61", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzreo", "iff", "INSN", "writes", "to", "an", "extension", "core", "register", "." ]

[ "arc", "0", "32", "61", "1", "0" ]

[]

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

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

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

[]

[ "<s>", "const", "CallLowering", "*", "ARMSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "unsigned", "ErrorInfo", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "processInstruction", "(", "Inst", ",", "Operands", ")", ";", "forwardITPosition", "(", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_ConversionFail", ":", "return", "true", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "static", "int", "mingw32_gt_pch_use_address", "(", "void", "*", "addr", ",", "size_t", "size", ",", "int", "fd", ",", "size_t", "offset", ")", "{", "void", "*", "mmap_addr", ";", "HANDLE", "mmap_handle", ";", "char", "*", "object_name", "=", "NULL", ";", "OSVERSIONINFO", "version_info", ";", "int", "r", ";", "version_info", ".", "dwOSVersionInfoSize", "=", "sizeof", "(", "version_info", ")", ";", "if", "(", "size", "==", "0", ")", "return", "0", ";", "if", "(", "(", "offset", "&", "(", "va_granularity", "-", "1", ")", ")", "!=", "0", "||", "size", ">", "pch_VA_max_size", ")", "return", "-", "1", ";", "GetVersionEx", "(", "&", "version_info", ")", ";", "if", "(", "version_info", ".", "dwMajorVersion", ">", "4", ")", "{", "char", "local_object_name", "[", "sizeof", "(", "OBJECT_NAME_FMT", ")", "+", "sizeof", "(", "DWORD", ")", "*", "2", "]", ";", "snprintf", "(", "local_object_name", ",", "sizeof", "(", "local_object_name", ")", ",", "OBJECT_NAME_FMT", "\"%lx\"", ",", "GetCurrentProcessId", "(", ")", ")", ";", "object_name", "=", "local_object_name", ";", "}", "mmap_handle", "=", "CreateFileMappingA", "(", "(", "HANDLE", ")", "_get_osfhandle", "(", "fd", ")", ",", "NULL", ",", "PAGE_WRITECOPY", "|", "SEC_COMMIT", ",", "0", ",", "0", ",", "object_name", ")", ";", "if", "(", "mmap_handle", "==", "NULL", ")", "{", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"CreateFileMapping\"", ")", ";", "return", "-", "1", ";", "}", "for", "(", "r", "=", "0", ";", "r", "<", "5", ";", "r", "++", ")", "{", "mmap_addr", "=", "MapViewOfFileEx", "(", "mmap_handle", ",", "FILE_MAP_COPY", ",", "0", ",", "offset", ",", "size", ",", "addr", ")", ";", "if", "(", "mmap_addr", "==", "addr", ")", "break", ";", "if", "(", "r", "!=", "4", ")", "Sleep", "(", "500", ")", ";", "}", "if", "(", "mmap_addr", "!=", "addr", ")", "{", "w32_error", "(", "__FUNCTION__", ",", "__FILE__", ",", "__LINE__", ",", "\"MapViewOfFileEx\"", ")", ";", "CloseHandle", "(", "mmap_handle", ")", ";", "return", "-", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "ADDR", "is", "an", "address", "returned", "by", "gt_pch_get_address", ".", "Attempt", "to", "allocate", "SIZE", "bytes", "at", "the", "same", "address", "and", "load", "it", "with", "the", "data", "from", "FD", "at", "OFFSET", ".", "Return", "-1", "if", "we", "could", "n't", "allocate", "memory", "at", "ADDR", ",", "return", "0", "if", "the", "memory", "is", "allocated", "but", "the", "data", "not", "loaded", ",", "return", "1", "if", "done", "." ]

[ "i386", "0", "0", "1", "0", "1", "4", "2", "\"%lx\"", "0", "0", "\"CreateFileMapping\"", "1", "0", "5", "0", "4", "500", "\"MapViewOfFileEx\"", "1", "1" ]

[]

[ "<s>", "void", "BPFInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "BPF", "::", "GPRRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BPF", "::", "STD", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "&", "BPF", "::", "GPR32RegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BPF", "::", "STW32", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "BPF::GPRRegClass", "BPF::STD", "0", "BPF::GPR32RegClass", "BPF::STW32", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "bool", "isUnspillableTerminatorImpl", "(", "const", "MachineInstr", "*", "MI", ")", "const", "override", "{", "return", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopEndDec", "||", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2DoLoopStartTP", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "terminator", "MI", "is", "not", "expected", "to", "spill", "." ]

[ "ARM", "ARM::t2LoopEndDec", "ARM::t2DoLoopStartTP" ]

[]

[ "<s>", "static", "char", "*", "detect_caches_darwin", "(", "void", ")", "{", "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "size_t", "len", "=", "4", ";", "static", "int", "l1_size_name", "[", "2", "]", "=", "{", "CTL_HW", ",", "HW_L1DCACHESIZE", "}", ";", "static", "int", "l1_line_name", "[", "2", "]", "=", "{", "CTL_HW", ",", "HW_CACHELINE", "}", ";", "static", "int", "l2_size_name", "[", "2", "]", "=", "{", "CTL_HW", ",", "HW_L2CACHESIZE", "}", ";", "sysctl", "(", "l1_size_name", ",", "2", ",", "&", "l1_sizekb", ",", "&", "len", ",", "NULL", ",", "0", ")", ";", "sysctl", "(", "l1_line_name", ",", "2", ",", "&", "l1_line", ",", "&", "len", ",", "NULL", ",", "0", ")", ";", "sysctl", "(", "l2_size_name", ",", "2", ",", "&", "l2_sizekb", ",", "&", "len", ",", "NULL", ",", "0", ")", ";", "l1_assoc", "=", "0", ";", "return", "describe_cache", "(", "l1_sizekb", "/", "1024", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", "/", "1024", ")", ";", "}", "</s>" ]

[ "Returns", "the", "description", "of", "caches", "on", "Darwin", "." ]

[ "powerpcspe", "4", "2", "2", "2", "2", "0", "2", "0", "2", "0", "0", "1024", "1024" ]

[]

[ "<s>", "static", "bool", "aarch64_short_vector_p", "(", "const_tree", "type", ",", "machine_mode", "mode", ")", "{", "poly_int64", "size", "=", "-", "1", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "aarch64_sve", "::", "builtin_type_p", "(", "type", ")", ")", "return", "false", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_FLOAT", ")", "{", "if", "(", "type", "&&", "aarch64_some_values_include_pst_objects_p", "(", "type", ")", ")", "gcc_assert", "(", "!", "TARGET_SVE", "||", "aarch64_sve_mode_p", "(", "mode", ")", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "if", "(", "known_eq", "(", "size", ",", "8", ")", "||", "known_eq", "(", "size", ",", "16", ")", ")", "{", "gcc_assert", "(", "!", "aarch64_sve_mode_p", "(", "mode", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "the", "type", ",", "as", "described", "by", "TYPE", "and", "MODE", ",", "is", "a", "short", "vector", "type", "as", "described", "in", "AAPCS64", "\\S", "4.1.2", ".", "See", "the", "comment", "above", "aarch64_composite_type_p", "for", "the", "notes", "on", "MODE", "." ]

[ "aarch64", "1", "aarch64_sve::builtin_type_p", "8", "16" ]

[]

[ "<s>", "void", "rs6000_emit_swdivsf", "(", "rtx", "res", ",", "rtx", "n", ",", "rtx", "d", ")", "{", "rtx", "x0", ",", "e0", ",", "e1", ",", "y1", ",", "u0", ",", "v0", ",", "one", ";", "x0", "=", "gen_reg_rtx", "(", "SFmode", ")", ";", "e0", "=", "gen_reg_rtx", "(", "SFmode", ")", ";", "e1", "=", "gen_reg_rtx", "(", "SFmode", ")", ";", "y1", "=", "gen_reg_rtx", "(", "SFmode", ")", ";", "u0", "=", "gen_reg_rtx", "(", "SFmode", ")", ";", "v0", "=", "gen_reg_rtx", "(", "SFmode", ")", ";", "one", "=", "force_reg", "(", "SFmode", ",", "CONST_DOUBLE_FROM_REAL_VALUE", "(", "dconst1", ",", "SFmode", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x0", ",", "gen_rtx_UNSPEC", "(", "SFmode", ",", "gen_rtvec", "(", "1", ",", "d", ")", ",", "UNSPEC_FRES", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e0", ",", "gen_rtx_MINUS", "(", "SFmode", ",", "one", ",", "gen_rtx_MULT", "(", "SFmode", ",", "d", ",", "x0", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "e1", ",", "gen_rtx_PLUS", "(", "SFmode", ",", "gen_rtx_MULT", "(", "SFmode", ",", "e0", ",", "e0", ")", ",", "e0", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "y1", ",", "gen_rtx_PLUS", "(", "SFmode", ",", "gen_rtx_MULT", "(", "SFmode", ",", "e1", ",", "x0", ")", ",", "x0", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "u0", ",", "gen_rtx_MULT", "(", "SFmode", ",", "n", ",", "y1", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "v0", ",", "gen_rtx_MINUS", "(", "SFmode", ",", "n", ",", "gen_rtx_MULT", "(", "SFmode", ",", "d", ",", "u0", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "res", ",", "gen_rtx_PLUS", "(", "SFmode", ",", "gen_rtx_MULT", "(", "SFmode", ",", "v0", ",", "y1", ")", ",", "u0", ")", ")", ")", ";", "}", "</s>" ]

[ "Newton-Raphson", "approximation", "of", "single-precision", "floating", "point", "divide", "n/d", ".", "Assumes", "no", "trapping", "math", "and", "finite", "arguments", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "bool", "BPFAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "unsigned", "RegNo", "=", "MatchRegisterName", "(", "Name", ")", ";", "if", "(", "RegNo", "!=", "0", ")", "{", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "-", "1", ")", ";", "Operands", ".", "push_back", "(", "BPFOperand", "::", "createReg", "(", "RegNo", ",", "NameLoc", ",", "E", ")", ")", ";", "}", "else", "if", "(", "BPFOperand", "::", "isValidIdAtStart", "(", "Name", ")", ")", "Operands", ".", "push_back", "(", "BPFOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "else", "return", "Error", "(", "NameLoc", ",", "\"invalid register/token name\"", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperandAsOperator", "(", "Operands", ")", "==", "MatchOperand_Success", ")", "continue", ";", "if", "(", "parseRegister", "(", "Operands", ")", "==", "MatchOperand_Success", ")", "continue", ";", "if", "(", "parseImmediate", "(", "Operands", ")", "!=", "MatchOperand_Success", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "1", "BPFOperand::createReg", "BPFOperand::isValidIdAtStart", "BPFOperand::createToken", "\"invalid register/token name\"", "\"unexpected token\"", "\"unexpected token\"" ]

[]

[ "<s>", "int", "h8300_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "pc_size", "=", "POINTER_SIZE", "/", "BITS_PER_UNIT", ";", "int", "fp_size", "=", "frame_pointer_needed", "*", "UNITS_PER_WORD", ";", "int", "saved_regs_size", "=", "0", ";", "int", "frame_size", "=", "round_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "HARD_FRAME_POINTER_REGNUM", ";", "regno", "++", ")", "if", "(", "WORD_REG_USED", "(", "regno", ")", ")", "saved_regs_size", "+=", "UNITS_PER_WORD", ";", "saved_regs_size", "-=", "fp_size", ";", "switch", "(", "to", ")", "{", "case", "HARD_FRAME_POINTER_REGNUM", ":", "switch", "(", "from", ")", "{", "case", "ARG_POINTER_REGNUM", ":", "return", "pc_size", "+", "fp_size", ";", "case", "RETURN_ADDRESS_POINTER_REGNUM", ":", "return", "fp_size", ";", "case", "FRAME_POINTER_REGNUM", ":", "return", "-", "saved_regs_size", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "STACK_POINTER_REGNUM", ":", "switch", "(", "from", ")", "{", "case", "ARG_POINTER_REGNUM", ":", "return", "pc_size", "+", "saved_regs_size", "+", "frame_size", ";", "case", "RETURN_ADDRESS_POINTER_REGNUM", ":", "return", "saved_regs_size", "+", "frame_size", ";", "case", "FRAME_POINTER_REGNUM", ":", "return", "frame_size", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Function", "for", "INITIAL_ELIMINATION_OFFSET", "(", "FROM", ",", "TO", ",", "OFFSET", ")", ".", "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "h8300", "0", "0" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "PushOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STMDB_UPD", ":", "ARM", "::", "STMDB_UPD", ";", "unsigned", "PushOneOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VSTMDDB_UPD", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea1Register", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea2Register", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "true", ",", "&", "isARMArea3Register", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM::t2STMDB_UPD", "ARM::STMDB_UPD", "ARM::t2STR_PRE", "ARM::STR_PRE_IMM", "ARM::VSTMDDB_UPD", "ARM", "ARM", "0", "ARM" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "CodeEmitter", ".", "reset", "(", "TM", ".", "getTarget", "(", ")", ".", "createMCCodeEmitter", "(", "*", "Subtarget", "->", "getInstrInfo", "(", ")", ",", "*", "Subtarget", "->", "getRegisterInfo", "(", ")", ",", "MF", ".", "getContext", "(", ")", ")", ")", ";", "EmitFPOData", "=", "Subtarget", "->", "isTargetWin32", "(", ")", "&&", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getCodeViewFlag", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Local", "=", "MF", ".", "getFunction", "(", ")", "->", "hasLocalLinkage", "(", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Local", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "emitXRayTable", "(", ")", ";", "EmitFPOData", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MipsABIInfo", "ABI", "=", "STI", ".", "getABI", "(", ")", ";", "unsigned", "FP", "=", "ABI", ".", "GetFramePtr", "(", ")", ";", "unsigned", "BP", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "S7_64", ":", "Mips", "::", "S7", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "FP", ")", ";", "if", "(", "hasBP", "(", "MF", ")", ")", "setAliasRegs", "(", "MF", ",", "SavedRegs", ",", "BP", ")", ";", "if", "(", "MipsFI", "->", "callsEhReturn", "(", ")", ")", "MipsFI", "->", "createEhDataRegsFI", "(", ")", ";", "if", "(", "MipsFI", "->", "isISR", "(", ")", ")", "MipsFI", "->", "createISRRegFI", "(", ")", ";", "if", "(", "ExpandPseudo", "(", "MF", ")", ".", "expand", "(", ")", ")", "{", "const", "TargetRegisterClass", "&", "RC", "=", "STI", ".", "isGP64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "uint64_t", "MaxSPOffset", "=", "estimateStackSize", "(", "MF", ")", ";", "if", "(", "isIntN", "(", "STI", ".", "hasMSA", "(", ")", "?", "10", ":", "16", ",", "MaxSPOffset", ")", "&&", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ")", "return", ";", "const", "TargetRegisterClass", "&", "RC", "=", "ABI", ".", "ArePtrs64bit", "(", ")", "?", "Mips", "::", "GPR64RegClass", ":", "Mips", "::", "GPR32RegClass", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "TRI", "->", "getSpillSize", "(", "RC", ")", ",", "TRI", "->", "getSpillAlignment", "(", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips::S7_64", "Mips::S7", "Mips", "Mips", "Mips", "Mips", "Mips::GPR64RegClass", "Mips::GPR32RegClass", "10", "16", "Mips::GPR64RegClass", "Mips::GPR32RegClass" ]

[]

[ "<s>", "const", "BPFTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsReadPortLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "IG", ",", "const", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "PV", ",", "std", "::", "vector", "<", "BankSwizzle", ">", "&", "ValidSwizzle", ")", "const", "{", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">", ">", ">", "IGSrcs", ";", "ValidSwizzle", ".", "clear", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "IG", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "IGSrcs", ".", "push_back", "(", "ExtractSrcs", "(", "IG", "[", "i", "]", ",", "PV", ")", ")", ";", "unsigned", "Op", "=", "getOperandIdx", "(", "IG", "[", "i", "]", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "bank_swizzle", ")", ";", "ValidSwizzle", ".", "push_back", "(", "(", "R600InstrInfo", "::", "BankSwizzle", ")", "IG", "[", "i", "]", "->", "getOperand", "(", "Op", ")", ".", "getImm", "(", ")", ")", ";", "}", "bool", "Result", "=", "recursiveFitsFPLimitation", "(", "IGSrcs", ",", "ValidSwizzle", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "the", "order", "VEC_012", "<", "VEC_021", "<", "VEC_120", "<", "VEC_102", "<", "VEC_201", "<", "VEC_210", "returns", "true", "and", "the", "first", "(", "in", "lexical", "order", ")", "BankSwizzle", "affectation", "starting", "from", "the", "one", "already", "provided", "in", "the", "Instruction", "Group", "MIs", "that", "fits", "Read", "Port", "limitations", "in", "BS", "if", "available", "." ]

[ "R600", "0" ]

[]

[ "<s>", "bool", "SICFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", "||", "TRI", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC" ]

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "const", "unsigned", "FixupKind", "=", "Fixup", ".", "getKind", "(", ")", ";", "switch", "(", "FixupKind", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "fixup_Mips_CALL_HI16", ":", "case", "Mips", "::", "fixup_Mips_CALL_LO16", ":", "case", "Mips", "::", "fixup_Mips_CALL16", ":", "case", "Mips", "::", "fixup_Mips_GOT", ":", "case", "Mips", "::", "fixup_Mips_GOT_PAGE", ":", "case", "Mips", "::", "fixup_Mips_GOT_OFST", ":", "case", "Mips", "::", "fixup_Mips_GOT_DISP", ":", "case", "Mips", "::", "fixup_Mips_GOT_HI16", ":", "case", "Mips", "::", "fixup_Mips_GOT_LO16", ":", "case", "Mips", "::", "fixup_Mips_GOTTPREL", ":", "case", "Mips", "::", "fixup_Mips_DTPREL_HI", ":", "case", "Mips", "::", "fixup_Mips_DTPREL_LO", ":", "case", "Mips", "::", "fixup_Mips_TLSGD", ":", "case", "Mips", "::", "fixup_Mips_TLSLDM", ":", "case", "Mips", "::", "fixup_Mips_TPREL_HI", ":", "case", "Mips", "::", "fixup_Mips_TPREL_LO", ":", "case", "Mips", "::", "fixup_MICROMIPS_CALL16", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_DISP", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_PAGE", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT_OFST", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOT16", ":", "case", "Mips", "::", "fixup_MICROMIPS_GOTTPREL", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_HI16", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_DTPREL_LO16", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_GD", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_LDM", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_HI16", ":", "case", "Mips", "::", "fixup_MICROMIPS_TLS_TPREL_LO16", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "Mips", "Mips", "Mips::fixup_Mips_CALL_HI16", "Mips::fixup_Mips_CALL_LO16", "Mips::fixup_Mips_CALL16", "Mips::fixup_Mips_GOT", "Mips::fixup_Mips_GOT_PAGE", "Mips::fixup_Mips_GOT_OFST", "Mips::fixup_Mips_GOT_DISP", "Mips::fixup_Mips_GOT_HI16", "Mips::fixup_Mips_GOT_LO16", "Mips::fixup_Mips_GOTTPREL", "Mips::fixup_Mips_DTPREL_HI", "Mips::fixup_Mips_DTPREL_LO", "Mips::fixup_Mips_TLSGD", "Mips::fixup_Mips_TLSLDM", "Mips::fixup_Mips_TPREL_HI", "Mips::fixup_Mips_TPREL_LO", "Mips::fixup_MICROMIPS_CALL16", "Mips::fixup_MICROMIPS_GOT_DISP", "Mips::fixup_MICROMIPS_GOT_PAGE", "Mips::fixup_MICROMIPS_GOT_OFST", "Mips::fixup_MICROMIPS_GOT16", "Mips::fixup_MICROMIPS_GOTTPREL", "Mips::fixup_MICROMIPS_TLS_DTPREL_HI16", "Mips::fixup_MICROMIPS_TLS_DTPREL_LO16", "Mips::fixup_MICROMIPS_TLS_GD", "Mips::fixup_MICROMIPS_TLS_LDM", "Mips::fixup_MICROMIPS_TLS_TPREL_HI16", "Mips::fixup_MICROMIPS_TLS_TPREL_LO16" ]

[]

[ "<s>", "void", "WebAssemblyTargetELFStreamer", "::", "emitLocal", "(", "ArrayRef", "<", "MVT", ">", "Types", ")", "{", "Streamer", ".", "EmitIntValue", "(", "WebAssembly", "::", "DotLocal", ",", "sizeof", "(", "uint64_t", ")", ")", ";", "EncodeTypes", "(", "Streamer", ",", "Types", ")", ";", "}", "</s>" ]

[ ".local" ]

[ "WebAssembly", "WebAssembly", "WebAssembly::DotLocal" ]

[]

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

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

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

[]

[ "<s>", "bool", "LC3FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "LC3", "LC3" ]

[]

[ "<s>", "static", "rtx", "riscv_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "riscv_arg_info", "info", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "NULL", ";", "return", "riscv_get_arg_info", "(", "&", "info", ",", "cum", ",", "mode", ",", "type", ",", "named", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "riscv" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "ReplaceTailWithBranchTo", "(", "MachineBasicBlock", "::", "iterator", "Tail", ",", "MachineBasicBlock", "*", "NewDest", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "Tail", "->", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasITBlocks", "(", ")", "||", "Tail", "->", "isBranch", "(", ")", ")", "{", "TargetInstrInfo", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "return", ";", "}", "Register", "PredReg", ";", "ARMCC", "::", "CondCodes", "CC", "=", "getInstrPredicate", "(", "*", "Tail", ",", "PredReg", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Tail", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "--", "MBBI", ";", "TargetInstrInfo", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "if", "(", "CC", "!=", "ARMCC", "::", "AL", ")", "{", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", "->", "begin", "(", ")", ";", "unsigned", "Count", "=", "4", ";", "while", "(", "Count", "&&", "MBBI", "!=", "E", ")", "{", "if", "(", "MBBI", "->", "isDebugInstr", "(", ")", ")", "{", "--", "MBBI", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MBBI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Count", "==", "4", ")", "MBBI", "->", "eraseFromParent", "(", ")", ";", "else", "{", "unsigned", "MaskOn", "=", "1", "<<", "Count", ";", "unsigned", "MaskOff", "=", "~", "(", "MaskOn", "-", "1", ")", ";", "MBBI", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "(", "Mask", "&", "MaskOff", ")", "|", "MaskOn", ")", ";", "}", "return", ";", "}", "--", "MBBI", ";", "--", "Count", ";", "}", "}", "}", "</s>" ]

[ "Delete", "the", "instruction", "OldInst", "and", "everything", "after", "it", ",", "replacing", "it", "with", "an", "unconditional", "branch", "to", "NewDest", "." ]

[ "ARM", "ARM", "ARM", "ARMCC::CondCodes", "ARMCC::AL", "ARMCC::AL", "4", "ARM::t2IT", "1", "4", "1", "1", "1" ]

[]

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

[ "getFramePointerSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "frame", "pointer", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "xstormy16_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "'B'", ":", "{", "static", "int", "bits_set", "[", "8", "]", "=", "{", "0", ",", "1", ",", "1", ",", "2", ",", "1", ",", "2", ",", "2", ",", "3", "}", ";", "HOST_WIDE_INT", "xx", "=", "1", ";", "HOST_WIDE_INT", "l", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "xx", "=", "INTVAL", "(", "x", ")", ";", "else", "output_operand_lossage", "(", "\"'B' operand is not constant\"", ")", ";", "if", "(", "bits_set", "[", "xx", "&", "7", "]", "<=", "1", ")", "{", "if", "(", "(", "~", "xx", "&", "~", "(", "HOST_WIDE_INT", ")", "0xff", ")", "==", "0", ")", "xx", "&=", "0xff", ";", "else", "if", "(", "(", "~", "xx", "&", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", "==", "0", ")", "xx", "&=", "0xffff", ";", "l", "=", "exact_log2", "(", "xx", ")", ";", "}", "else", "{", "if", "(", "(", "xx", "&", "~", "(", "HOST_WIDE_INT", ")", "0xff", ")", "==", "0", ")", "xx", "|=", "~", "(", "HOST_WIDE_INT", ")", "0xff", ";", "else", "if", "(", "(", "xx", "&", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", "==", "0", ")", "xx", "|=", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ";", "l", "=", "exact_log2", "(", "~", "xx", ")", ";", "}", "if", "(", "l", "==", "-", "1", ")", "output_operand_lossage", "(", "\"'B' operand has multiple bits set\"", ")", ";", "fprintf", "(", "file", ",", "IMMEDIATE_PREFIX", "HOST_WIDE_INT_PRINT_DEC", ",", "l", ")", ";", "return", ";", "}", "case", "'C'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "assemble_name", "(", "file", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "output_asm_label", "(", "x", ")", ";", "else", "xstormy16_print_operand_address", "(", "file", ",", "x", ")", ";", "return", ";", "case", "'o'", ":", "case", "'O'", ":", "{", "HOST_WIDE_INT", "xx", "=", "0", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "xx", "=", "INTVAL", "(", "x", ")", ";", "else", "output_operand_lossage", "(", "\"'o' operand is not constant\"", ")", ";", "if", "(", "code", "==", "'O'", ")", "xx", "=", "-", "xx", ";", "fprintf", "(", "file", ",", "IMMEDIATE_PREFIX", "HOST_WIDE_INT_PRINT_DEC", ",", "xx", "-", "1", ")", ";", "return", ";", "}", "case", "'b'", ":", "{", "HOST_WIDE_INT", "xx", "=", "1", ";", "HOST_WIDE_INT", "l", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "xx", "=", "INTVAL", "(", "x", ")", ";", "else", "output_operand_lossage", "(", "\"'B' operand is not constant\"", ")", ";", "l", "=", "7", "-", "xx", ";", "fputs", "(", "IMMEDIATE_PREFIX", ",", "file", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "l", ")", ";", "return", ";", "}", "case", "0", ":", "break", ";", "default", ":", "output_operand_lossage", "(", "\"xstormy16_print_operand: unknown code\"", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fputs", "(", "reg_names", "[", "REGNO", "(", "x", ")", "]", ",", "file", ")", ";", "break", ";", "case", "MEM", ":", "xstormy16_print_operand_address", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "default", ":", "fputs", "(", "IMMEDIATE_PREFIX", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "}", "return", ";", "}", "</s>" ]

[ "Print", "an", "operand", "to", "an", "assembler", "instruction", "." ]

[ "stormy16", "8", "0", "1", "1", "2", "1", "2", "2", "3", "1", "\"'B' operand is not constant\"", "7", "1", "0xff", "0", "0xff", "0xffff", "0", "0xffff", "0xff", "0", "0xff", "0xffff", "0", "0xffff", "1", "\"'B' operand has multiple bits set\"", "0", "0", "\"'o' operand is not constant\"", "1", "1", "\"'B' operand is not constant\"", "7", "0", "\"xstormy16_print_operand: unknown code\"", "0" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "static", "inline", "SlotWithTag", "getTombstoneKey", "(", ")", "{", "return", "{", "-", "3", ",", "-", "3", ";", "}", "</s>" ]

[ "Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "." ]

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

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "CallOperandVal", "==", "NULL", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'c'", ":", "case", "'l'", ":", "case", "'x'", ":", "if", "(", "type", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "if", "(", "isa", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'R'", ":", "weight", "=", "CW_Memory", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "int", "bpf_core_get_index", "(", "const", "tree", "node", ")", "{", "enum", "tree_code", "code", "=", "TREE_CODE", "(", "node", ")", ";", "if", "(", "code", "==", "FIELD_DECL", ")", "{", "int", "idx", "=", "bpf_core_get_sou_member_index", "(", "ctf_get_tu_ctfc", "(", ")", ",", "node", ")", ";", "if", "(", "idx", ">=", "0", ")", "return", "idx", ";", "}", "else", "if", "(", "code", "==", "ARRAY_REF", "||", "code", "==", "ARRAY_RANGE_REF", "||", "code", "==", "MEM_REF", ")", "{", "tree", "index", "=", "TREE_OPERAND", "(", "node", ",", "1", ")", ";", "if", "(", "TREE_CODE", "(", "index", ")", "==", "INTEGER_CST", "&&", "tree_fits_shwi_p", "(", "index", ")", ")", "return", "tree_to_shwi", "(", "index", ")", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Compute", "the", "index", "of", "the", "NODE", "in", "its", "immediate", "container", ".", "NODE", "should", "be", "a", "FIELD_DECL", "(", "i.e", ".", "of", "struct", "or", "union", ")", ",", "or", "an", "ARRAY_REF", "." ]

[ "bpf", "0", "1", "1" ]

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CHERICFI", "&&", "STI", ".", "isCheri", "(", ")", "&&", "!", "STI", ".", "getABI", "(", ")", ".", "IsCheriPureCap", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "CSI", ")", "if", "(", "I", ".", "getReg", "(", ")", "==", "Mips", "::", "RA_64", ")", "{", "CSI", ".", "push_back", "(", "CalleeSavedInfo", "(", "Mips", "::", "C16", ",", "0", ")", ")", ";", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

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

[]

[ "<s>", "static", "int", "s390_fn_types_compatible", "(", "enum", "s390_builtin_ov_type_index", "typeindex", ",", "vec", "<", "tree", ",", "va_gc", ">", "*", "arglist", ")", "{", "unsigned", "int", "i", ";", "int", "match_type", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "vec_safe_length", "(", "arglist", ")", ";", "i", "++", ")", "{", "tree", "b_arg_type", "=", "s390_builtin_types", "[", "s390_builtin_ov_types", "[", "typeindex", "]", "[", "i", "+", "1", "]", "]", ";", "tree", "in_arg", "=", "(", "*", "arglist", ")", "[", "i", "]", ";", "tree", "in_type", "=", "TREE_TYPE", "(", "in_arg", ")", ";", "if", "(", "TREE_CODE", "(", "b_arg_type", ")", "==", "VECTOR_TYPE", ")", "{", "if", "(", "b_arg_type", "!=", "in_type", "&&", "TYPE_MAIN_VARIANT", "(", "b_arg_type", ")", "!=", "TYPE_MAIN_VARIANT", "(", "in_type", ")", ")", "goto", "mismatch", ";", "}", "if", "(", "lang_hooks", ".", "types_compatible_p", "(", "in_type", ",", "b_arg_type", ")", ")", "continue", ";", "if", "(", "lang_hooks", ".", "types_compatible_p", "(", "lang_hooks", ".", "types", ".", "type_promotes_to", "(", "in_type", ")", ",", "lang_hooks", ".", "types", ".", "type_promotes_to", "(", "b_arg_type", ")", ")", ")", "{", "match_type", "++", ";", "continue", ";", "}", "if", "(", "TREE_CODE", "(", "b_arg_type", ")", "==", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "in_type", ")", "==", "INTEGER_TYPE", ")", "{", "match_type", "++", ";", "continue", ";", "}", "if", "(", "POINTER_TYPE_P", "(", "b_arg_type", ")", "&&", "POINTER_TYPE_P", "(", "in_type", ")", "&&", "!", "(", "TYPE_QUALS", "(", "TREE_TYPE", "(", "in_type", ")", ")", "&", "~", "TYPE_QUALS", "(", "TREE_TYPE", "(", "b_arg_type", ")", ")", ")", "&&", "(", "TYPE_QUALS", "(", "TREE_TYPE", "(", "b_arg_type", ")", ")", "&", "~", "TYPE_QUALS", "(", "TREE_TYPE", "(", "in_type", ")", ")", ")", ")", "{", "tree", "qual_in_type", "=", "build_qualified_type", "(", "TREE_TYPE", "(", "in_type", ")", ",", "TYPE_QUALS", "(", "TREE_TYPE", "(", "b_arg_type", ")", ")", ")", ";", "if", "(", "lang_hooks", ".", "types_compatible_p", "(", "qual_in_type", ",", "TREE_TYPE", "(", "b_arg_type", ")", ")", ")", "{", "match_type", "++", ";", "continue", ";", "}", "}", "mismatch", ":", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\" mismatch in operand: %d\\n\"", ",", "i", "+", "1", ")", ";", "return", "INT_MAX", ";", "}", "return", "match_type", ";", "}", "</s>" ]

[ "Check", "whether", "the", "arguments", "in", "ARGLIST", "match", "the", "function", "type", "DEF_TYPE", ".", "Return", "the", "number", "of", "argument", "types", "which", "required", "conversion/promotion", "in", "order", "to", "make", "it", "match", ".", "0", "stands", "for", "a", "perfect", "match", "-", "all", "operand", "types", "match", "without", "changes", "INT_MAX", "stands", "for", "a", "mismatch", "." ]

[ "s390", "0", "0", "1", "\" mismatch in operand: %d\\n\"", "1" ]

[]

[ "<s>", "static", "bool", "microblaze_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "return", "microblaze_hard_regno_mode_ok_p", "[", "mode", "]", "[", "regno", "]", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", ".", "In", "32", "bit", "mode", ",", "require", "that", "DImode", "and", "DFmode", "be", "in", "even", "registers", ".", "For", "DImode", ",", "this", "makes", "some", "of", "the", "insns", "easier", "to", "write", ",", "since", "you", "do", "n't", "have", "to", "worry", "about", "a", "DImode", "value", "in", "registers", "3", "&", "4", ",", "producing", "a", "result", "in", "4", "&", "5", ".", "To", "make", "the", "code", "simpler", ",", "the", "hook", "now", "just", "references", "an", "array", "built", "in", "override_options", "." ]

[ "microblaze" ]

[]

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

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

[ "mproc", "mproc", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SRA", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ExternalSymbol", ":", "return", "LowerExternalSymbol", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::SHL", "ISD::SRL", "ISD::SRA", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ExternalSymbol", "ISD::SETCC", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SIGN_EXTEND", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::VASTART", "ISD::JumpTable", "\"unimplemented operand\"" ]

[]

[ "<s>", "char", "*", "aarch64_output_sve_prefetch", "(", "const", "char", "*", "mnemonic", ",", "rtx", "prfop_rtx", ",", "const", "char", "*", "suffix", ")", "{", "static", "char", "buffer", "[", "128", "]", ";", "aarch64_svprfop", "prfop", "=", "(", "aarch64_svprfop", ")", "INTVAL", "(", "prfop_rtx", ")", ";", "unsigned", "int", "written", "=", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"%s\\t%s, %s\"", ",", "mnemonic", ",", "svprfop_token", "(", "prfop", ")", ",", "suffix", ")", ";", "gcc_assert", "(", "written", "<", "sizeof", "(", "buffer", ")", ")", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "string", "for", "an", "SVE", "prefetch", "operation", "with", "mnemonic", "MNEMONIC", ",", "given", "that", "PRFOP_RTX", "is", "the", "prefetch", "operation", "and", "that", "SUFFIX", "is", "the", "format", "for", "the", "remaining", "operands", "." ]

[ "aarch64", "128", "\"%s\\t%s, %s\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "markPhysRegUsed", "(", "PhysReg", ")", ";", "if", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "<", "32", ")", "{", "auto", "Copy", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "::", "scalar", "(", "32", ")", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "Copy", ")", ";", "return", ";", "}", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "LocInfo", "::", "SExt", ":", "case", "CCValAssign", "::", "LocInfo", "::", "ZExt", ":", "case", "CCValAssign", "::", "LocInfo", "::", "AExt", ":", "{", "auto", "Copy", "=", "MIRBuilder", ".", "buildCopy", "(", "LLT", "{", "VA", ".", "getLocVT", "(", ")", "}", ",", "PhysReg", ")", ";", "MIRBuilder", ".", "buildTrunc", "(", "ValVReg", ",", "Copy", ")", ";", "break", ";", "}", "default", ":", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "break", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "const", "char", "*", "unicosmk_ssib_name", "(", ")", "{", "static", "char", "name", "[", "256", "]", ";", "rtx", "x", ";", "const", "char", "*", "fnname", ";", "int", "len", ";", "x", "=", "DECL_RTL", "(", "cfun", "->", "decl", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MEM", ")", "abort", "(", ")", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "abort", "(", ")", ";", "fnname", "=", "XSTR", "(", "x", ",", "0", ")", ";", "STRIP_NAME_ENCODING", "(", "fnname", ",", "fnname", ")", ";", "len", "=", "strlen", "(", "fnname", ")", ";", "if", "(", "len", "+", "SSIB_PREFIX_LEN", ">", "255", ")", "len", "=", "255", "-", "SSIB_PREFIX_LEN", ";", "strcpy", "(", "name", ",", "SSIB_PREFIX", ")", ";", "strncpy", "(", "name", "+", "SSIB_PREFIX_LEN", ",", "fnname", ",", "len", ")", ";", "name", "[", "len", "+", "SSIB_PREFIX_LEN", "]", "=", "0", ";", "return", "name", ";", "}", "</s>" ]

[ "Generate", "the", "name", "of", "the", "SSIB", "section", "for", "the", "current", "function", "." ]

[ "alpha", "256", "0", "0", "255", "255", "0" ]

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "STI", "->", "isTargetDarwin", "(", ")", ")", "-", "STI", "->", "isTargetDarwin", "(", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "32", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "32", "AArch64::FPR128_loRegClassID", "16" ]

[]

[ "<s>", "static", "unsigned", "loongarch_save_libcall_count", "(", "unsigned", "mask", ")", "{", "for", "(", "unsigned", "n", "=", "GP_REG_LAST", ";", "n", ">", "GP_REG_FIRST", ";", "n", "--", ")", "if", "(", "BITSET_P", "(", "mask", ",", "n", ")", ")", "return", "CALLEE_SAVED_REG_NUMBER", "(", "n", ")", "+", "1", ";", "abort", "(", ")", ";", "}", "</s>" ]

[ "Determine", "which", "GPR", "save/restore", "routine", "to", "call", "." ]

[ "loongarch", "1" ]

[]

[ "<s>", "static", "const", "char", "*", "getName", "(", ")", "{", "return", "DEBUG_TYPE", ";", "}", "</s>" ]

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

[ "X86" ]

[]

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

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

[ "LM32", "LM32" ]

[]

[ "<s>", "void", "M88kInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "MachineMemOperand", "*", "MMO", "=", "getMachineMemOperand", "(", "MBB", ",", "FrameIndex", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "M88k", "::", "LDriw", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k::LDriw", "0" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "TPC" ]

[]

[ "<s>", "static", "rtx", "mips16_stub_call_address", "(", "mips_one_only_stub", "*", "stub", ")", "{", "rtx", "fn", "=", "mips16_stub_function", "(", "stub", "->", "get_name", "(", ")", ")", ";", "SYMBOL_REF_FLAGS", "(", "fn", ")", "|=", "SYMBOL_FLAG_LOCAL", ";", "if", "(", "!", "call_insn_operand", "(", "fn", ",", "VOIDmode", ")", ")", "fn", "=", "force_reg", "(", "Pmode", ",", "fn", ")", ";", "return", "fn", ";", "}", "</s>" ]

[ "Return", "a", "legitimate", "call", "address", "for", "STUB", ",", "given", "that", "STUB", "is", "a", "MIPS16", "support", "function", "." ]

[ "mips" ]

[]

[ "<s>", "MachineBasicBlock", "*", "LinearizedRegion", "::", "getExit", "(", ")", "{", "return", "Exit", ";", "}", "</s>" ]

[ "Get", "the", "exit", "BasicBlock", "of", "the", "Region", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "LinearizedRegion", "::", "contains", "(", "MachineBasicBlock", "*", "MBB", ")", "{", "return", "MBBs", ".", "count", "(", "MBB", ")", "==", "1", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "int", "const_uint32_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "op", ")", ">=", "0", "&&", "INTVAL", "(", "op", ")", "<=", "0xffffffffL", ")", ")", ";", "return", "(", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "op", ")", ">=", "0", ")", "||", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "&&", "CONST_DOUBLE_HIGH", "(", "op", ")", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Accept", "integer", "operands", "in", "the", "range", "0", "..", "0xffffffff", ".", "We", "have", "to", "check", "the", "range", "carefully", "since", "this", "predicate", "is", "used", "in", "DImode", "contexts", ".", "Also", ",", "we", "need", "some", "extra", "crud", "to", "make", "it", "work", "when", "hosted", "on", "64-bit", "machines", "." ]

[ "arc", "0", "0xffffffffL", "0", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_expand_sve_ld1rq", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "src", "=", "force_const_mem", "(", "GET_MODE", "(", "src", ")", ",", "src", ")", ";", "if", "(", "!", "src", ")", "return", "false", ";", "if", "(", "!", "aarch64_sve_ld1rq_operand_p", "(", "src", ")", ")", "{", "rtx", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "src", ",", "0", ")", ")", ";", "src", "=", "replace_equiv_address", "(", "src", ",", "addr", ")", ";", "}", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "pred_mode", "=", "aarch64_sve_pred_mode", "(", "mode", ")", ";", "rtx", "ptrue", "=", "aarch64_ptrue_reg", "(", "pred_mode", ")", ";", "emit_insn", "(", "gen_aarch64_sve_ld1rq", "(", "mode", ",", "dest", ",", "src", ",", "ptrue", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Try", "to", "force", "128-bit", "vector", "value", "SRC", "into", "memory", "and", "use", "LD1RQ", "to", "fetch", "the", "memory", "image", "into", "DEST", ".", "Return", "true", "on", "success", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "unsigned", "SystemZInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "isInlineAsm", "(", ")", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "char", "*", "AsmStr", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ";", "return", "getInlineAsmLength", "(", "AsmStr", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SystemZ", "::", "PATCHPOINT", ")", "return", "PatchPointOpers", "(", "&", "MI", ")", ".", "getNumPatchBytes", "(", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SystemZ", "::", "STACKMAP", ")", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SystemZ", "::", "FENTRY_CALL", ")", "return", "6", ";", "return", "MI", ".", "getDesc", "(", ")", ".", "getSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "SystemZ", "SystemZ", "0", "SystemZ::PATCHPOINT", "SystemZ::STACKMAP", "1", "SystemZ::FENTRY_CALL", "6" ]

[]

[ "<s>", "static", "reg_class_t", "cris_preferred_reload_class", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "rclass", ")", "{", "if", "(", "rclass", "!=", "ACR_REGS", "&&", "rclass", "!=", "MOF_REGS", "&&", "rclass", "!=", "MOF_SRP_REGS", "&&", "rclass", "!=", "SRP_REGS", "&&", "rclass", "!=", "CC0_REGS", "&&", "rclass", "!=", "SPECIAL_REGS", ")", "return", "GENERAL_REGS", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_PREFERRED_RELOAD_CLASS", ".", "It", "seems", "like", "gcc", "(", "2.7.2", "and", "2.9x", "of", "2000-03-22", ")", "may", "send", "``", "NO_REGS", "''", "as", "the", "class", "for", "a", "constant", "(", "testcase", ":", "__Mul", "in", "arit.c", ")", ".", "To", "avoid", "forcing", "out", "a", "constant", "into", "the", "constant", "pool", ",", "we", "will", "trap", "this", "case", "and", "return", "something", "a", "bit", "more", "sane", ".", "FIXME", ":", "Check", "if", "this", "is", "a", "bug", ".", "Beware", "that", "we", "must", "not", "``", "override", "''", "classes", "that", "can", "be", "specified", "as", "constraint", "letters", ",", "or", "else", "asm", "operands", "using", "them", "will", "fail", "when", "they", "need", "to", "be", "reloaded", ".", "FIXME", ":", "Investigate", "whether", "that", "constitutes", "a", "bug", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumTCycles", ",", "unsigned", "ExtraTCycles", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumFCycles", ",", "unsigned", "ExtraFCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_store_pair", "(", "machine_mode", "mode", ",", "rtx", "mem1", ",", "rtx", "reg1", ",", "rtx", "mem2", ",", "rtx", "reg2", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "gen_store_pair_dw_didi", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "case", "E_DFmode", ":", "return", "gen_store_pair_dw_dfdf", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "case", "E_TFmode", ":", "return", "gen_store_pair_dw_tftf", "(", "mem1", ",", "reg1", ",", "mem2", ",", "reg2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "and", "return", "a", "store", "pair", "instruction", "of", "mode", "MODE", "to", "store", "register", "REG1", "to", "MEM1", "and", "register", "REG2", "to", "MEM2", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "void", "arm_block_arith_comp_libfuncs_for_mode", "(", "machine_mode", "mode", ")", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "neg_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "eq_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "ne_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "lt_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "le_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "ge_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "gt_optab", ",", "mode", ",", "NULL", ")", ";", "set_optab_libfunc", "(", "unord_optab", ",", "mode", ",", "NULL", ")", ";", "}", "</s>" ]

[ "Record", "that", "we", "have", "no", "arithmetic", "or", "comparison", "libfuncs", "for", "machine", "mode", "MODE", "." ]

[ "arm" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "changeSection", "(", "const", "MCSection", "*", "CurSection", ",", "MCSection", "*", "Section", ",", "const", "MCExpr", "*", "SubSection", ",", "raw_ostream", "&", "OS", ")", "{", "assert", "(", "!", "SubSection", "&&", "\"SubSection is not null!\"", ")", ";", "const", "MCObjectFileInfo", "*", "FI", "=", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getObjectFileInfo", "(", ")", ";", "if", "(", "isDwarfSection", "(", "FI", ",", "CurSection", ")", ")", "OS", "<<", "\"\\t}\\n\"", ";", "if", "(", "isDwarfSection", "(", "FI", ",", "Section", ")", ")", "{", "outputDwarfFileDirectives", "(", ")", ";", "OS", "<<", "\"\\t.section\"", ";", "Section", "->", "printSwitchToSection", "(", "*", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", ",", "getStreamer", "(", ")", ".", "getContext", "(", ")", ".", "getTargetTriple", "(", ")", ",", "OS", ",", "SubSection", ")", ";", "OS", "<<", "\"\\t{\\n\"", ";", "HasSections", "=", "true", ";", "}", "}", "</s>" ]

[ "Update", "streamer", "for", "a", "new", "active", "section", "." ]

[ "NVPTX", "NVPTX", "\"SubSection is not null!\"", "\"\\t}\\n\"", "\"\\t.section\"", "\"\\t{\\n\"" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "1", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_RESTORE", ";", "break", ";", "}", "}", "else", "if", "(", "shouldTryToSpillVGPRs", "(", "MF", ")", "&&", "RI", ".", "hasVGPRs", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_RESTORE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_RESTORE", ";", "break", ";", "case", "96", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_RESTORE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_RESTORE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_RESTORE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_RESTORE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "1", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "1", "8", "32", "SI", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "8", "32", "SI", "64", "SI", "96", "SI", "128", "SI", "256", "SI", "512", "SI", "1", "4", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "{", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "STRH", ":", "case", "ARM", "::", "STRBi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "t2STRi8", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VSTRS", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "tLDRspi", ":", "break", ";", "default", ":", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "8", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "FPOffset", "-=", "80", ";", "Offset", "+=", "MFI", ".", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "unsigned", "StackAlign", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "!", "(", "(", "MFI", ".", "getLocalFrameMaxAlign", "(", ")", ">", "StackAlign", ")", "&&", "canRealignStack", "(", "MF", ")", ")", ")", "{", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "getFrameRegister", "(", "MF", ")", ",", "FPOffset", ")", ")", "return", "false", ";", "}", "if", "(", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "ARM", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARM::LDRi12", "ARM::LDRH", "ARM::LDRBi12", "ARM::STRi12", "ARM::STRH", "ARM::STRBi12", "ARM::t2LDRi12", "ARM::t2LDRi8", "ARM::t2STRi12", "ARM::t2STRi8", "ARM::VLDRS", "ARM::VLDRD", "ARM::VSTRS", "ARM::VSTRD", "ARM::tSTRspi", "ARM::tLDRspi", "ARM", "ARM", "ARM", "8", "80", "128", "ARM::SP" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "Opc", ";", "if", "(", "MSP430", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "MSP430", "::", "MOV16rr", ";", "else", "if", "(", "MSP430", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "MSP430", "::", "MOV8rr", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::GR16RegClass", "MSP430::MOV16rr", "MSP430::GR8RegClass", "MSP430::MOV8rr", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "static", "unsigned", "long", "arm_compute_save_reg0_reg12_mask", "(", "void", ")", "{", "unsigned", "long", "func_type", "=", "arm_current_func_type", "(", ")", ";", "unsigned", "long", "save_reg_mask", "=", "0", ";", "unsigned", "int", "reg", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", ")", "{", "unsigned", "int", "max_reg", ";", "if", "(", "ARM_FUNC_TYPE", "(", "func_type", ")", "==", "ARM_FT_FIQ", ")", "max_reg", "=", "7", ";", "else", "max_reg", "=", "12", ";", "for", "(", "reg", "=", "0", ";", "reg", "<=", "max_reg", ";", "reg", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "||", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "reg", "]", ")", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "crtl", "->", "uses_pic_offset_table", ")", "save_reg_mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "}", "else", "if", "(", "IS_VOLATILE", "(", "func_type", ")", ")", "{", "if", "(", "frame_pointer_needed", ")", "save_reg_mask", "|=", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "df_regs_ever_live_p", "(", "ARM_HARD_FRAME_POINTER_REGNUM", ")", ")", "save_reg_mask", "|=", "1", "<<", "ARM_HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "df_regs_ever_live_p", "(", "THUMB_HARD_FRAME_POINTER_REGNUM", ")", ")", "save_reg_mask", "|=", "1", "<<", "THUMB_HARD_FRAME_POINTER_REGNUM", ";", "}", "else", "{", "for", "(", "reg", "=", "0", ";", "reg", "<=", "11", ";", "reg", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "callee_saved_reg_p", "(", "reg", ")", ")", "save_reg_mask", "|=", "(", "1", "<<", "reg", ")", ";", "if", "(", "frame_pointer_needed", ")", "save_reg_mask", "|=", "1", "<<", "HARD_FRAME_POINTER_REGNUM", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_SINGLE_PIC_BASE", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "(", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", "||", "crtl", "->", "uses_pic_offset_table", ")", ")", "save_reg_mask", "|=", "1", "<<", "PIC_OFFSET_TABLE_REGNUM", ";", "if", "(", "IS_STACKALIGN", "(", "func_type", ")", ")", "save_reg_mask", "|=", "1", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "reg", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "reg", "==", "INVALID_REGNUM", ")", "break", ";", "save_reg_mask", "|=", "1", "<<", "reg", ";", "}", "}", "return", "save_reg_mask", ";", "}", "</s>" ]

[ "Compute", "the", "register", "save", "mask", "for", "registers", "0", "through", "12", "inclusive", ".", "This", "code", "is", "used", "by", "arm_compute_save_reg_mask", "." ]

[ "arm", "0", "7", "12", "0", "1", "1", "1", "1", "1", "0", "11", "1", "1", "1", "1", "0", "1" ]

[]

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

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

[ "TGSI", "TGSI" ]

[]

[ "<s>", "int", "mems_ok_for_quad_peep", "(", "rtx", "mem1", ",", "rtx", "mem2", ")", "{", "rtx", "addr1", ",", "addr2", ";", "unsigned", "int", "reg1", ",", "reg2", ";", "int", "offset1", ",", "offset2", ";", "if", "(", "MEM_VOLATILE_P", "(", "mem1", ")", "||", "MEM_VOLATILE_P", "(", "mem2", ")", ")", "return", "0", ";", "addr1", "=", "XEXP", "(", "mem1", ",", "0", ")", ";", "addr2", "=", "XEXP", "(", "mem2", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr1", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "0", ")", ")", "!=", "REG", ")", "return", "0", ";", "else", "{", "reg1", "=", "REGNO", "(", "XEXP", "(", "addr1", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "0", ";", "offset1", "=", "INTVAL", "(", "XEXP", "(", "addr1", ",", "1", ")", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addr1", ")", "!=", "REG", ")", "return", "0", ";", "else", "{", "reg1", "=", "REGNO", "(", "addr1", ")", ";", "offset1", "=", "0", ";", "}", "if", "(", "GET_CODE", "(", "addr2", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "0", ")", ")", "!=", "REG", ")", "return", "0", ";", "else", "{", "reg2", "=", "REGNO", "(", "XEXP", "(", "addr2", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "0", ";", "offset2", "=", "INTVAL", "(", "XEXP", "(", "addr2", ",", "1", ")", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addr2", ")", "!=", "REG", ")", "return", "0", ";", "else", "{", "reg2", "=", "REGNO", "(", "addr2", ")", ";", "offset2", "=", "0", ";", "}", "if", "(", "reg1", "!=", "reg2", ")", "return", "0", ";", "if", "(", "offset2", "!=", "offset1", "+", "8", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "1", "if", "addr1", "and", "addr2", "are", "suitable", "for", "lfq", "or", "stfq", "insn", ".", "addr1", "and", "addr2", "must", "be", "in", "consecutive", "memory", "locations", "(", "addr2", "==", "addr1", "+", "8", ")", "." ]

[ "rs6000", "0", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "0", "0", "1", "0", "1", "0", "0", "0", "8", "0", "1" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "size", ",", "const", "MemoryObject", "&", "region", ",", "uint64_t", "address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "CommentStream", "=", "&", "cStream", ";", "InternalInstruction", "internalInstr", ";", "dlog_t", "loggerFn", "=", "logger", ";", "if", "(", "&", "vStream", "==", "&", "nulls", "(", ")", ")", "loggerFn", "=", "0", ";", "int", "ret", "=", "decodeInstruction", "(", "&", "internalInstr", ",", "regionReader", ",", "(", "void", "*", ")", "&", "region", ",", "loggerFn", ",", "(", "void", "*", ")", "&", "vStream", ",", "(", "void", "*", ")", "MII", ",", "address", ",", "fMode", ")", ";", "if", "(", "ret", ")", "{", "size", "=", "internalInstr", ".", "readerCursor", "-", "address", ";", "return", "Fail", ";", "}", "else", "{", "size", "=", "internalInstr", ".", "length", ";", "return", "(", "!", "translateInstruction", "(", "instr", ",", "internalInstr", ",", "this", ")", ")", "?", "Success", ":", "Fail", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "unsigned", "R600RegisterInfo", "::", "getHWRegChan", "(", "unsigned", "reg", ")", "const", "{", "return", "this", "->", "getEncodingValue", "(", "reg", ")", ">>", "HW_CHAN_SHIFT", ";", "}", "</s>" ]

[ "get", "the", "HW", "encoding", "for", "a", "register", "'s", "channel", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "void", "PPCDispatchGroupSBHazardRecognizer", "::", "EmitInstruction", "(", "SUnit", "*", "SU", ")", "{", "const", "MCInstrDesc", "*", "MCID", "=", "DAG", "->", "getInstrDesc", "(", "SU", ")", ";", "if", "(", "MCID", ")", "{", "if", "(", "CurSlots", "==", "5", "||", "(", "MCID", "->", "isBranch", "(", ")", "&&", "CurBranches", "==", "1", ")", ")", "{", "CurGroup", ".", "clear", "(", ")", ";", "CurSlots", "=", "CurBranches", "=", "0", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**** Adding to dispatch group: \"", ")", ";", "LLVM_DEBUG", "(", "DAG", "->", "dumpNode", "(", "*", "SU", ")", ")", ";", "unsigned", "NSlots", ";", "bool", "MustBeFirst", "=", "mustComeFirst", "(", "MCID", ",", "NSlots", ")", ";", "if", "(", "MustBeFirst", "&&", "CurSlots", ")", "{", "CurSlots", "=", "CurBranches", "=", "0", ";", "CurGroup", ".", "clear", "(", ")", ";", "}", "CurSlots", "+=", "NSlots", ";", "CurGroup", ".", "push_back", "(", "SU", ")", ";", "if", "(", "MCID", "->", "isBranch", "(", ")", ")", "++", "CurBranches", ";", "}", "}", "return", "ScoreboardHazardRecognizer", "::", "EmitInstruction", "(", "SU", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "5", "1", "0", "\"**** Adding to dispatch group: \"", "0" ]

[]

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

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "Lanai" ]

[]

[ "<s>", "static", "bool", "spu_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", ")", "{", "return", "(", "GET_MODE_SIZE", "(", "from", ")", "==", "GET_MODE_SIZE", "(", "to", ")", "||", "(", "GET_MODE_SIZE", "(", "from", ")", "<=", "4", "&&", "GET_MODE_SIZE", "(", "to", ")", "<=", "4", ")", "||", "(", "GET_MODE_SIZE", "(", "from", ")", ">=", "16", "&&", "GET_MODE_SIZE", "(", "to", ")", ">=", "16", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", ".", "GCC", "assumes", "that", "modes", "are", "in", "the", "lowpart", "of", "a", "register", ",", "which", "is", "only", "true", "for", "SPU", "." ]

[ "spu", "4", "4", "16", "16" ]

[]

[ "<s>", "void", "rs6000_expand_extract_even", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "vec_perm_builder", "perm", "(", "nelt", ",", "nelt", ",", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "perm", ".", "quick_push", "(", "i", "*", "2", ")", ";", "rs6000_do_expand_vec_perm", "(", "target", ",", "op0", ",", "op1", ",", "vmode", ",", "perm", ")", ";", "}", "</s>" ]

[ "Expand", "an", "extract", "even", "operation", "." ]

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

[]

[ "<s>", "void", "WebAssemblyMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "isVariadic", "(", ")", ")", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "MI", ".", "getNumOperands", "(", ")", "-", "Desc", ".", "NumOperands", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "double", ">", "(", "MO", ".", "getFPImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "support", "::", "endian", "::", "Writer", "<", "support", "::", "little", ">", "(", "OS", ")", ".", "write", "<", "uint64_t", ">", "(", "0", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "(", "1", "+", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "isVariadic", "(", ")", "+", "i", ")", "*", "sizeof", "(", "uint64_t", ")", ",", "MO", ".", "getExpr", "(", ")", ",", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", "?", "FK_Data_8", ":", "FK_Data_4", ",", "MI", ".", "getLoc", "(", ")", ")", ")", ";", "++", "MCNumFixups", ";", "}", "else", "{", "llvm_unreachable", "(", "\"unexpected operand kind\"", ")", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "WebAssembly", "WebAssembly", "support::endian", "support::little", "support::endian", "support::little", "0", "support::endian", "support::little", "support::endian", "support::little", "support::endian", "support::little", "support::endian", "support::little", "0", "1", "\"unexpected operand kind\"" ]

[]

[ "<s>", "const", "char", "*", "msp430_select_hwmult_lib", "(", "int", "argc", "ATTRIBUTE_UNUSED", ",", "const", "char", "*", "*", "argv", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "switch", "(", "argc", ")", "{", "case", "1", ":", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"default\"", ")", ")", "error", "(", "\"unexpected argument to msp430_select_hwmult_lib: %s\"", ",", "argv", "[", "0", "]", ")", ";", "break", ";", "default", ":", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"hwmult\"", ")", "==", "0", ")", "{", "static", "struct", "hwmult_options", "{", "const", "char", "*", "name", ";", "const", "char", "*", "lib", ";", "}", "hwmult_options", "[", "]", "=", "{", "{", "\"none\"", ",", "\"-lmul_none\"", "}", ",", "{", "\"auto\"", ",", "\"-lmul_AUTO\"", "}", ",", "{", "\"16bit\"", ",", "\"-lmul_16\"", "}", ",", "{", "\"32bit\"", ",", "\"-lmul_32\"", "}", ",", "{", "\"f5series\"", ",", "\"-lmul_f5\"", "}", "}", ";", "for", "(", "i", "=", "ARRAY_SIZE", "(", "hwmult_options", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "argv", "[", "argc", "-", "1", "]", ",", "hwmult_options", "[", "i", "]", ".", "name", ")", "==", "0", ")", "return", "hwmult_options", "[", "i", "]", ".", "lib", ";", "}", "else", "if", "(", "strcasecmp", "(", "argv", "[", "0", "]", ",", "\"mcu\"", ")", "==", "0", ")", "{", "for", "(", "i", "=", "ARRAY_SIZE", "(", "msp430_mcu_data", ")", ";", "i", "--", ";", ")", "if", "(", "strcasecmp", "(", "argv", "[", "argc", "-", "1", "]", ",", "msp430_mcu_data", "[", "i", "]", ".", "name", ")", "==", "0", ")", "{", "switch", "(", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", ")", "{", "case", "0", ":", "return", "\"-lmul_none\"", ";", "case", "2", ":", "case", "1", ":", "return", "\"-lmul_16\"", ";", "case", "4", ":", "return", "\"-lmul_32\"", ";", "case", "8", ":", "return", "\"-lmul_f5\"", ";", "default", ":", "error", "(", "\"unrecognised hwpy field in msp430_mcu_data[%d]: %d\"", ",", "i", ",", "msp430_mcu_data", "[", "i", "]", ".", "hwmpy", ")", ";", "break", ";", "}", "}", "}", "else", "error", "(", "\"unexpected first argument to msp430_select_hwmult_lib: %s\"", ",", "argv", "[", "0", "]", ")", ";", "break", ";", "case", "0", ":", "error", "(", "\"msp430_select_hwmult_lib needs one or more arguments\"", ")", ";", "break", ";", "}", "return", "\"-lmul_none\"", ";", "}", "</s>" ]

[ "Implement", "spec", "function", "`", "msp430_hwmult_lib麓", "." ]

[ "msp430", "1", "0", "\"default\"", "\"unexpected argument to msp430_select_hwmult_lib: %s\"", "0", "0", "\"hwmult\"", "0", "\"none\"", "\"-lmul_none\"", "\"auto\"", "\"-lmul_AUTO\"", "\"16bit\"", "\"-lmul_16\"", "\"32bit\"", "\"-lmul_32\"", "\"f5series\"", "\"-lmul_f5\"", "1", "0", "0", "\"mcu\"", "0", "1", "0", "0", "\"-lmul_none\"", "2", "1", "\"-lmul_16\"", "4", "\"-lmul_32\"", "8", "\"-lmul_f5\"", "\"unrecognised hwpy field in msp430_mcu_data[%d]: %d\"", "\"unexpected first argument to msp430_select_hwmult_lib: %s\"", "0", "0", "\"msp430_select_hwmult_lib needs one or more arguments\"", "\"-lmul_none\"" ]

[]

[ "<s>", "unsigned", "XtensaRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

[ "Xtensa", "Xtensa", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_emit_move_si_sf_subreg", "(", "rtx", "dest", ",", "rtx", "source", ",", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_DIRECT_MOVE_64BIT", "&&", "!", "reload_in_progress", "&&", "!", "reload_completed", "&&", "!", "lra_in_progress", "&&", "(", "!", "SUBREG_P", "(", "dest", ")", "||", "!", "sf_subreg_operand", "(", "dest", ",", "mode", ")", ")", "&&", "SUBREG_P", "(", "source", ")", "&&", "sf_subreg_operand", "(", "source", ",", "mode", ")", ")", "{", "rtx", "inner_source", "=", "SUBREG_REG", "(", "source", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE", "(", "inner_source", ")", ";", "if", "(", "mode", "==", "SImode", "&&", "inner_mode", "==", "SFmode", ")", "{", "emit_insn", "(", "gen_movsi_from_sf", "(", "dest", ",", "inner_source", ")", ")", ";", "return", "true", ";", "}", "if", "(", "mode", "==", "SFmode", "&&", "inner_mode", "==", "SImode", ")", "{", "emit_insn", "(", "gen_movsf_from_si", "(", "dest", ",", "inner_source", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "to", "change", "moves", "with", ":", "(", "SUBREG", ":", "SF", "(", "REG", ":", "SI", ")", ")", "and", "(", "SUBREG", ":", "SI", "(", "REG", ":", "SF", ")", ")", "into", "separate", "UNSPEC", "insns", ".", "In", "the", "PowerPC", "architecture", ",", "scalar", "SFmode", "values", "are", "stored", "as", "DFmode", "values", "in", "the", "VSX", "registers", ".", "We", "need", "to", "convert", "the", "bits", "before", "we", "can", "use", "a", "direct", "move", "or", "operate", "on", "the", "bits", "in", "the", "vector", "register", "as", "an", "integer", "type", ".", "Skip", "things", "like", "(", "set", "(", "SUBREG", ":", "SI", "(", "...", ")", "(", "SUBREG", ":", "SI", "(", "...", ")", ")", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "hasBranchDivergence", "(", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "NVPTX" ]

[]

[ "<s>", "void", "bfin_expand_epilogue", "(", "int", "need_return", ",", "int", "eh_return", ")", "{", "rtx", "spreg", "=", "gen_rtx_REG", "(", "Pmode", ",", "REG_SP", ")", ";", "e_funkind", "fkind", "=", "funkind", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ";", "if", "(", "fkind", "!=", "SUBROUTINE", ")", "{", "expand_interrupt_handler_epilogue", "(", "spreg", ",", "fkind", ")", ";", "return", ";", "}", "do_unlink", "(", "spreg", ",", "get_frame_size", "(", ")", ",", "false", ")", ";", "expand_epilogue_reg_restore", "(", "spreg", ",", "false", ",", "false", ")", ";", "if", "(", "!", "need_return", ")", "return", ";", "if", "(", "eh_return", ")", "emit_insn", "(", "gen_addsi3", "(", "spreg", ",", "spreg", ",", "gen_rtx_REG", "(", "Pmode", ",", "REG_P2", ")", ")", ")", ";", "emit_jump_insn", "(", "gen_return_internal", "(", "GEN_INT", "(", "SUBROUTINE", ")", ")", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "for", "the", "epilogue", "of", "the", "current", "function", ".", "NEED_RETURN", "is", "zero", "if", "this", "is", "for", "a", "sibcall", ".", "EH_RETURN", "is", "nonzero", "if", "we", "'re", "expanding", "an", "eh_return", "pattern", "." ]

[ "bfin" ]

[]

[ "<s>", "bool", "isTarget64BitILP32", "(", ")", "const", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", "||", "TargetTriple", ".", "isOSNaCl", "(", ")", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "ILP32", "programming", "model", "(", "x32", "ABI", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "enum", "reg_class", "preferred_reload_class", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "enum", "reg_class", "class", ")", "{", "return", "class", ";", "}", "</s>" ]

[ "Given", "an", "rtx", "X", "being", "reloaded", "into", "a", "reg", "required", "to", "be", "in", "class", "CLASS", ",", "return", "the", "class", "of", "reg", "to", "actually", "use", ".", "In", "general", "this", "is", "just", "CLASS", ";", "but", "on", "some", "machines", "in", "some", "cases", "it", "is", "preferable", "to", "use", "a", "more", "restrictive", "class", ".", "Also", ",", "we", "must", "ensure", "that", "a", "PLUS", "is", "reloaded", "either", "into", "an", "accumulator", "or", "an", "address", "register", "." ]

[ "avr" ]

[]

[ "<s>", "unsigned", "int", "execute_omp_gcn", "(", "void", ")", "{", "tree", "thr_num_tree", "=", "builtin_decl_explicit", "(", "BUILT_IN_OMP_GET_THREAD_NUM", ")", ";", "tree", "thr_num_id", "=", "DECL_NAME", "(", "thr_num_tree", ")", ";", "tree", "team_num_tree", "=", "builtin_decl_explicit", "(", "BUILT_IN_OMP_GET_TEAM_NUM", ")", ";", "tree", "team_num_id", "=", "DECL_NAME", "(", "team_num_tree", ")", ";", "basic_block", "bb", ";", "gimple_stmt_iterator", "gsi", ";", "unsigned", "int", "todo", "=", "0", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "for", "(", "gsi", "=", "gsi_start_bb", "(", "bb", ")", ";", "!", "gsi_end_p", "(", "gsi", ")", ";", "gsi_next", "(", "&", "gsi", ")", ")", "{", "gimple", "*", "call", "=", "gsi_stmt", "(", "gsi", ")", ";", "tree", "decl", ";", "if", "(", "is_gimple_call", "(", "call", ")", "&&", "(", "decl", "=", "gimple_call_fndecl", "(", "call", ")", ")", ")", "{", "tree", "decl_id", "=", "DECL_NAME", "(", "decl", ")", ";", "tree", "lhs", "=", "gimple_get_lhs", "(", "call", ")", ";", "if", "(", "decl_id", "==", "thr_num_id", ")", "{", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "fprintf", "(", "dump_file", ",", "\"Replace '%s' with __builtin_gcn_dim_pos.\\n\"", ",", "IDENTIFIER_POINTER", "(", "decl_id", ")", ")", ";", "tree", "fn", "=", "targetm", ".", "builtin_decl", "(", "GCN_BUILTIN_OMP_DIM_POS", ",", "0", ")", ";", "tree", "fnarg", "=", "build_int_cst", "(", "unsigned_type_node", ",", "1", ")", ";", "gimple", "*", "stmt", "=", "gimple_build_call", "(", "fn", ",", "1", ",", "fnarg", ")", ";", "gimple_call_set_lhs", "(", "stmt", ",", "lhs", ")", ";", "gsi_replace", "(", "&", "gsi", ",", "stmt", ",", "true", ")", ";", "todo", "|=", "TODO_update_ssa", ";", "}", "else", "if", "(", "decl_id", "==", "team_num_id", ")", "{", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "fprintf", "(", "dump_file", ",", "\"Replace '%s' with __builtin_gcn_dim_pos.\\n\"", ",", "IDENTIFIER_POINTER", "(", "decl_id", ")", ")", ";", "tree", "fn", "=", "targetm", ".", "builtin_decl", "(", "GCN_BUILTIN_OMP_DIM_POS", ",", "0", ")", ";", "tree", "fnarg", "=", "build_zero_cst", "(", "unsigned_type_node", ")", ";", "gimple", "*", "stmt", "=", "gimple_build_call", "(", "fn", ",", "1", ",", "fnarg", ")", ";", "gimple_call_set_lhs", "(", "stmt", ",", "lhs", ")", ";", "gsi_replace", "(", "&", "gsi", ",", "stmt", ",", "true", ")", ";", "todo", "|=", "TODO_update_ssa", ";", "}", "}", "}", "return", "todo", ";", "}", "</s>" ]

[ "{", "{", "{", "OMP", "GCN", "pass", ".", "This", "pass", "is", "intended", "to", "make", "any", "GCN-specfic", "transformations", "to", "OpenMP", "target", "regions", ".", "At", "present", ",", "its", "only", "purpose", "is", "to", "convert", "some", "``", "omp", "''", "built-in", "functions", "to", "use", "closer-to-the-metal", "``", "gcn", "''", "built-in", "functions", "." ]

[ "gcn", "0", "\"Replace '%s' with __builtin_gcn_dim_pos.\\n\"", "0", "1", "1", "\"Replace '%s' with __builtin_gcn_dim_pos.\\n\"", "0", "1" ]

[]

[ "<s>", "static", "int", "branch_dest", "(", "rtx", "branch", ")", "{", "rtx", "dest", ";", "int", "dest_uid", ";", "rtx", "pat", "=", "PATTERN", "(", "branch", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "dest", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "dest", ")", "==", "IF_THEN_ELSE", ")", "dest", "=", "XEXP", "(", "dest", ",", "1", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "return", "INSN_ADDRESSES", "(", "dest_uid", ")", ";", "}", "</s>" ]

[ "Return", "the", "destination", "address", "of", "BRANCH", ".", "We", "need", "to", "use", "this", "instead", "of", "get_attr_length", ",", "because", "the", "cbranch_with_nops", "pattern", "conservatively", "sets", "its", "length", "to", "6", ",", "and", "we", "still", "prefer", "to", "use", "shorter", "sequences", "." ]

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

[]

[ "<s>", "int", "h8300_current_function_interrupt_function_p", "(", "void", ")", "{", "return", "(", "h8300_interrupt_function_p", "(", "current_function_decl", ")", "||", "h8300_monitor_function_p", "(", "current_function_decl", ")", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "current", "function", "is", "an", "interrupt", "function", "." ]

[ "h8300" ]

[]

[ "<s>", "DiagnosticInfoUnsupported", "::", "DiagnosticInfoUnsupported", "(", "const", "Function", "&", "Fn", ",", "const", "Twine", "&", "Desc", ",", "DiagnosticSeverity", "Severity", ")", ":", "DiagnosticInfo", "(", "getKindID", "(", ")", ",", "Severity", ")", ",", "Description", "(", "Desc", ")", ",", "Fn", "(", "Fn", ")", "{", "}", "</s>" ]

[ "Fn", "is", "the", "function", "where", "the", "diagnostic", "is", "being", "emitted", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "CJGAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "0" ]

[]

[ "<s>", "static", "rtx", "alpha_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", ")", ";", "tree", "arg", ";", "call_expr_arg_iterator", "iter", ";", "enum", "insn_code", "icode", ";", "rtx", "op", "[", "MAX_ARGS", "]", ",", "pat", ";", "int", "arity", ";", "bool", "nonvoid", ";", "if", "(", "fcode", ">=", "ALPHA_BUILTIN_max", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "icode", "=", "code_for_builtin", "[", "fcode", "]", ";", "if", "(", "icode", "==", "0", ")", "internal_error", "(", "\"bad builtin fcode\"", ")", ";", "nonvoid", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "!=", "void_type_node", ";", "arity", "=", "0", ";", "FOR_EACH_CALL_EXPR_ARG", "(", "arg", ",", "iter", ",", "exp", ")", "{", "const", "struct", "insn_operand_data", "*", "insn_op", ";", "if", "(", "arg", "==", "error_mark_node", ")", "return", "NULL_RTX", ";", "if", "(", "arity", ">", "MAX_ARGS", ")", "return", "NULL_RTX", ";", "insn_op", "=", "&", "insn_data", "[", "icode", "]", ".", "operand", "[", "arity", "+", "nonvoid", "]", ";", "op", "[", "arity", "]", "=", "expand_expr", "(", "arg", ",", "NULL_RTX", ",", "insn_op", "->", "mode", ",", "EXPAND_NORMAL", ")", ";", "if", "(", "!", "(", "*", "insn_op", "->", "predicate", ")", "(", "op", "[", "arity", "]", ",", "insn_op", "->", "mode", ")", ")", "op", "[", "arity", "]", "=", "copy_to_mode_reg", "(", "insn_op", "->", "mode", ",", "op", "[", "arity", "]", ")", ";", "arity", "++", ";", "}", "if", "(", "nonvoid", ")", "{", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "if", "(", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "}", "switch", "(", "arity", ")", "{", "case", "0", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "break", ";", "case", "1", ":", "if", "(", "nonvoid", ")", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ")", ";", "else", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op", "[", "0", "]", ")", ";", "break", ";", "case", "2", ":", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op", "[", "0", "]", ",", "op", "[", "1", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "if", "(", "nonvoid", ")", "return", "target", ";", "else", "return", "const0_rtx", ";", "}", "</s>" ]

[ "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", "." ]

[ "alpha", "0", "\"bad builtin fcode\"", "0", "\"bad builtin fcode\"", "0", "0", "0", "0", "1", "0", "0", "2", "0", "1" ]

[]

[ "<s>", "static", "tree", "ix86_build_builtin_va_list_64", "(", "void", ")", "{", "tree", "f_gpr", ",", "f_fpr", ",", "f_ovf", ",", "f_sav", ",", "record", ",", "type_decl", ";", "record", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_gpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"gp_offset\"", ")", ",", "unsigned_type_node", ")", ";", "f_fpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"fp_offset\"", ")", ",", "unsigned_type_node", ")", ";", "f_ovf", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"overflow_arg_area\"", ")", ",", "ptr_type_node", ")", ";", "f_sav", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"reg_save_area\"", ")", ",", "ptr_type_node", ")", ";", "va_list_gpr_counter_field", "=", "f_gpr", ";", "va_list_fpr_counter_field", "=", "f_fpr", ";", "DECL_FIELD_CONTEXT", "(", "f_gpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ovf", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_sav", ")", "=", "record", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_gpr", ";", "DECL_CHAIN", "(", "f_gpr", ")", "=", "f_fpr", ";", "DECL_CHAIN", "(", "f_fpr", ")", "=", "f_ovf", ";", "DECL_CHAIN", "(", "f_ovf", ")", "=", "f_sav", ";", "layout_type", "(", "record", ")", ";", "TYPE_ATTRIBUTES", "(", "record", ")", "=", "tree_cons", "(", "get_identifier", "(", "\"sysv_abi va_list\"", ")", ",", "NULL_TREE", ",", "TYPE_ATTRIBUTES", "(", "record", ")", ")", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Create", "the", "va_list", "data", "type", "." ]

[ "i386", "\"__va_list_tag\"", "\"gp_offset\"", "\"fp_offset\"", "\"overflow_arg_area\"", "\"reg_save_area\"", "\"sysv_abi va_list\"" ]

[]

[ "<s>", "static", "int", "s390_sched_variable_issue", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "last_scheduled_insn", "=", "insn", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2827_ZEC12", "&&", "reload_completed", "&&", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "s390_sched_state", "=", "S390_SCHED_STATE_CRACKED", ";", "else", "if", "(", "(", "mask", "&", "S390_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "0", "||", "(", "mask", "&", "S390_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "s390_sched_state", "=", "S390_SCHED_STATE_NORMAL", ";", "else", "{", "switch", "(", "s390_sched_state", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "S390_SCHED_STATE_NORMAL", ":", "if", "(", "s390_sched_state", "==", "S390_SCHED_STATE_NORMAL", ")", "s390_sched_state", "=", "1", ";", "else", "s390_sched_state", "++", ";", "break", ";", "case", "S390_SCHED_STATE_CRACKED", ":", "s390_sched_state", "=", "S390_SCHED_STATE_NORMAL", ";", "break", ";", "}", "}", "if", "(", "s390_tune", "==", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "i", ";", "unsigned", "unit_mask", ",", "m", "=", "1", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "gcc_assert", "(", "units", "<=", "MAX_SCHED_UNITS", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "last_scheduled_unit_distance", "[", "i", "]", "=", "0", ";", "else", "if", "(", "last_scheduled_unit_distance", "[", "i", "]", "<", "MAX_SCHED_MIX_DISTANCE", ")", "last_scheduled_unit_distance", "[", "i", "]", "++", ";", "}", "if", "(", "verbose", ">", "5", ")", "{", "unsigned", "int", "sched_mask", ";", "sched_mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: insn %d: \"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_CRACKED", ",", "cracked", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_EXPANDED", ",", "expanded", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_ENDGROUP", ",", "endgroup", ")", ";", "PRINT_SCHED_ATTR", "(", "S390_SCHED_ATTR_MASK_GROUPALONE", ",", "groupalone", ")", ";", "if", "(", "s390_tune", "==", "PROCESSOR_2964_Z13", ")", "{", "unsigned", "int", "unit_mask", ",", "m", "=", "1", ";", "int", "units", ",", "j", ";", "unit_mask", "=", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "fprintf", "(", "file", ",", "\"(units:\"", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "units", ";", "j", "++", ",", "m", "<<=", "1", ")", "if", "(", "m", "&", "unit_mask", ")", "fprintf", "(", "file", ",", "\" %d\"", ",", "j", ")", ";", "fprintf", "(", "file", ",", "\")\"", ")", ";", "}", "fprintf", "(", "file", ",", "\" sched state: %d\\n\"", ",", "s390_sched_state", ")", ";", "if", "(", "s390_tune", "==", "PROCESSOR_2964_Z13", ")", "{", "int", "units", ",", "j", ";", "s390_get_unit_mask", "(", "insn", ",", "&", "units", ")", ";", "fprintf", "(", "file", ",", "\";;\\t\\tBACKEND: units unused for: \"", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "units", ";", "j", "++", ")", "fprintf", "(", "file", ",", "\"%d:%d \"", ",", "j", ",", "last_scheduled_unit_distance", "[", "j", "]", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "}", "}", "}", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", ")", "return", "more", "-", "1", ";", "else", "return", "more", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "via", "hook", "TARGET_SCHED_VARIABLE_ISSUE", "after", "the", "scheduler", "has", "issued", "INSN", ".", "It", "stores", "the", "last", "issued", "insn", "into", "last_scheduled_insn", "in", "order", "to", "make", "it", "available", "for", "s390_sched_reorder", "." ]

[ "s390", "0", "0", "0", "0", "0", "0", "1", "2", "1", "1", "0", "1", "0", "5", "\";;\\t\\tBACKEND: insn %d: \"", "1", "\"(units:\"", "0", "1", "\" %d\"", "\")\"", "\" sched state: %d\\n\"", "\";;\\t\\tBACKEND: units unused for: \"", "0", "\"%d:%d \"", "\"\\n\"", "1" ]

[]

[ "<s>", "TargetPassConfig", "*", "XNCMTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "XNCMPassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "XNCM", "XNCM", "XNCM" ]

[]

[ "<s>", "bool", "WaitInsert", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "StrictFP", ")", ")", "return", "false", ";", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", ".", "begin", "(", ")", ";", "MI", "!=", "MBB", ".", "end", "(", ")", ";", "++", "MI", ")", "{", "if", "(", "!", "isX87Instruction", "(", "*", "MI", ")", ")", "continue", ";", "if", "(", "!", "(", "MI", "->", "mayRaiseFPException", "(", ")", "||", "MI", "->", "mayLoadOrStore", "(", ")", ")", "||", "isX87ControlInstruction", "(", "*", "MI", ")", ")", "continue", ";", "MachineBasicBlock", "::", "iterator", "AfterMI", "=", "std", "::", "next", "(", "MI", ")", ";", "if", "(", "AfterMI", "!=", "MBB", ".", "end", "(", ")", "&&", "isX87Instruction", "(", "*", "AfterMI", ")", "&&", "!", "isX87NonWaitingControlInstruction", "(", "*", "AfterMI", ")", ")", "continue", ";", "BuildMI", "(", "MBB", ",", "AfterMI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "WAIT", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nInsert wait after:\\t\"", "<<", "*", "MI", ")", ";", "++", "MI", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::WAIT", "\"\\nInsert wait after:\\t\"" ]

[]

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

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "void", "iq2000_annotate_frame_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "dwarf_pattern", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "dwarf_pattern", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Make", "INSN", "frame", "related", "and", "note", "that", "it", "performs", "the", "frame-related", "operation", "DWARF_PATTERN", "." ]

[ "iq2000", "1" ]

[]

[ "<s>", "bool", "ix86_valid_target_attribute_p", "(", "tree", "fndecl", ",", "tree", "ARG_UNUSED", "(", "name", ")", ",", "tree", "args", ",", "int", "flags", ")", "{", "struct", "gcc_options", "func_options", ",", "func_options_set", ";", "tree", "new_target", ",", "new_optimize", ";", "bool", "ret", "=", "true", ";", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", "&&", "TREE_CHAIN", "(", "args", ")", "==", "NULL_TREE", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "args", ")", ")", ",", "\"default\"", ")", "==", "0", ")", "return", "true", ";", "if", "(", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "==", "target_attribute_cache", "[", "1", "]", "||", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "==", "NULL_TREE", ")", "&&", "(", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "==", "target_attribute_cache", "[", "2", "]", "||", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "==", "NULL_TREE", ")", "&&", "simple_cst_list_equal", "(", "args", ",", "target_attribute_cache", "[", "0", "]", ")", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "target_attribute_cache", "[", "1", "]", ";", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "target_attribute_cache", "[", "2", "]", ";", "return", "true", ";", "}", "tree", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "tree", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "!", "func_optimize", ")", "func_optimize", "=", "old_optimize", ";", "memset", "(", "&", "func_options", ",", "0", ",", "sizeof", "(", "func_options", ")", ")", ";", "init_options_struct", "(", "&", "func_options", ",", "NULL", ")", ";", "lang_hooks", ".", "init_options_struct", "(", "&", "func_options", ")", ";", "memset", "(", "&", "func_options_set", ",", "0", ",", "sizeof", "(", "func_options_set", ")", ")", ";", "cl_optimization_restore", "(", "&", "func_options", ",", "&", "func_options_set", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "tree", "old_target", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ";", "if", "(", "old_target", "==", "NULL_TREE", ")", "old_target", "=", "target_option_default_node", ";", "cl_target_option_restore", "(", "&", "func_options", ",", "&", "func_options_set", ",", "TREE_TARGET_OPTION", "(", "old_target", ")", ")", ";", "new_target", "=", "ix86_valid_target_attribute_tree", "(", "fndecl", ",", "args", ",", "&", "func_options", ",", "&", "func_options_set", ",", "flags", "==", "1", ")", ";", "new_optimize", "=", "build_optimization_node", "(", "&", "func_options", ",", "&", "func_options_set", ")", ";", "if", "(", "new_target", "==", "error_mark_node", ")", "ret", "=", "false", ";", "else", "if", "(", "new_target", ")", "{", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "==", "NULL_TREE", "&&", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "==", "NULL_TREE", ")", "{", "target_attribute_cache", "[", "0", "]", "=", "copy_list", "(", "args", ")", ";", "target_attribute_cache", "[", "1", "]", "=", "new_target", ";", "target_attribute_cache", "[", "2", "]", "=", "old_optimize", "!=", "new_optimize", "?", "new_optimize", ":", "NULL_TREE", ";", "}", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_target", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new_optimize", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "attribute", "(", "(", "target", "(", "``", "string", "''", ")", ")", ")", "." ]

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

[]

[ "<s>", "int", "R600InstrInfo", "::", "getOperandIdx", "(", "unsigned", "Opcode", ",", "R600Operands", "::", "Ops", "Op", ")", "const", "{", "unsigned", "TargetFlags", "=", "get", "(", "Opcode", ")", ".", "TSFlags", ";", "unsigned", "OpTableIdx", ";", "if", "(", "!", "HAS_NATIVE_OPERANDS", "(", "TargetFlags", ")", ")", "{", "switch", "(", "Op", ")", "{", "case", "R600Operands", "::", "DST", ":", "return", "0", ";", "case", "R600Operands", "::", "SRC0", ":", "return", "1", ";", "case", "R600Operands", "::", "SRC1", ":", "return", "2", ";", "case", "R600Operands", "::", "SRC2", ":", "return", "3", ";", "default", ":", "assert", "(", "!", "\"Unknown operand type for instruction\"", ")", ";", "return", "-", "1", ";", "}", "}", "if", "(", "TargetFlags", "&", "R600_InstFlag", "::", "OP1", ")", "{", "OpTableIdx", "=", "0", ";", "}", "else", "if", "(", "TargetFlags", "&", "R600_InstFlag", "::", "OP2", ")", "{", "OpTableIdx", "=", "1", ";", "}", "else", "{", "assert", "(", "(", "TargetFlags", "&", "R600_InstFlag", "::", "OP3", ")", "&&", "\"OP1, OP2, or OP3 not defined \"", "\"for this instruction\"", ")", ";", "OpTableIdx", "=", "2", ";", "}", "return", "R600Operands", "::", "ALUOpTable", "[", "OpTableIdx", "]", "[", "Op", "]", ";", "}", "</s>" ]

[ "Get", "the", "index", "of", "Op", "for", "the", "given", "Opcode", "." ]

[ "R600", "R600Operands::Ops", "R600Operands::DST", "0", "R600Operands::SRC0", "1", "R600Operands::SRC1", "2", "R600Operands::SRC2", "3", "\"Unknown operand type for instruction\"", "1", "R600_InstFlag::OP1", "0", "R600_InstFlag::OP2", "1", "R600_InstFlag::OP3", "\"OP1, OP2, or OP3 not defined \"", "\"for this instruction\"", "2", "R600Operands::ALUOpTable" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "Amount", "=", "alignTo", "(", "Amount", ",", "getStackAlign", "(", ")", ")", ";", "assert", "(", "isUInt", "<", "32", ">", "(", "Amount", ")", "&&", "\"exceeded stack address space size\"", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "Register", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "Op", "=", "IsDestroy", "?", "AMDGPU", "::", "S_SUB_U32", ":", "AMDGPU", "::", "S_ADD_U32", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "llvm_unreachable", "(", "\"is this used?\"", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "0", "0", "SI", "1", "0", "32", "\"exceeded stack address space size\"", "SI", "SI", "AMDGPU::S_SUB_U32", "AMDGPU::S_ADD_U32", "0", "\"is this used?\"" ]

[]

[ "<s>", "unsigned", "AlphaCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "{", "unsigned", "rv", "=", "0", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "rv", "=", "getAlphaRegNumber", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "rv", "=", "MO", ".", "getImm", "(", ")", ";", "}", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", "||", "MO", ".", "isSymbol", "(", ")", "||", "MO", ".", "isCPI", "(", ")", ")", "{", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "MO", "<<", "\" is a relocated op for \"", "<<", "MI", "<<", "\"\\n\"", ";", "unsigned", "Reloc", "=", "0", ";", "int", "Offset", "=", "0", ";", "bool", "useGOT", "=", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Alpha", "::", "BSR", ":", "Reloc", "=", "Alpha", "::", "reloc_bsr", ";", "break", ";", "case", "Alpha", "::", "LDLr", ":", "case", "Alpha", "::", "LDQr", ":", "case", "Alpha", "::", "LDBUr", ":", "case", "Alpha", "::", "LDWUr", ":", "case", "Alpha", "::", "LDSr", ":", "case", "Alpha", "::", "LDTr", ":", "case", "Alpha", "::", "LDAr", ":", "case", "Alpha", "::", "STQr", ":", "case", "Alpha", "::", "STLr", ":", "case", "Alpha", "::", "STWr", ":", "case", "Alpha", "::", "STBr", ":", "case", "Alpha", "::", "STSr", ":", "case", "Alpha", "::", "STTr", ":", "Reloc", "=", "Alpha", "::", "reloc_gprellow", ";", "break", ";", "case", "Alpha", "::", "LDAHr", ":", "Reloc", "=", "Alpha", "::", "reloc_gprelhigh", ";", "break", ";", "case", "Alpha", "::", "LDQl", ":", "Reloc", "=", "Alpha", "::", "reloc_literal", ";", "useGOT", "=", "true", ";", "break", ";", "case", "Alpha", "::", "LDAg", ":", "case", "Alpha", "::", "LDAHg", ":", "Reloc", "=", "Alpha", "::", "reloc_gpdist", ";", "Offset", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"unknown relocatable instruction\"", ")", ";", "}", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getGV", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Reloc", ",", "MO", ".", "getGlobal", "(", ")", ",", "Offset", ",", "isa", "<", "Function", ">", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "useGOT", ")", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getExtSym", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Reloc", ",", "MO", ".", "getSymbolName", "(", ")", ",", "Offset", ",", "true", ")", ")", ";", "else", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getConstPool", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Reloc", ",", "MO", ".", "getIndex", "(", ")", ",", "Offset", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "{", "MCE", ".", "addRelocation", "(", "MachineRelocation", "::", "getBB", "(", "MCE", ".", "getCurrentPCOffset", "(", ")", ",", "Alpha", "::", "reloc_bsr", ",", "MO", ".", "getMBB", "(", ")", ")", ")", ";", "}", "else", "{", "cerr", "<<", "\"ERROR: Unknown type of MachineOperand: \"", "<<", "MO", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "return", "rv", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "0", "Alpha", "\" is a relocated op for \"", "\"\\n\"", "0", "0", "Alpha::BSR", "Alpha::reloc_bsr", "Alpha::LDLr", "Alpha::LDQr", "Alpha::LDBUr", "Alpha::LDWUr", "Alpha::LDSr", "Alpha::LDTr", "Alpha::LDAr", "Alpha::STQr", "Alpha::STLr", "Alpha::STWr", "Alpha::STBr", "Alpha::STSr", "Alpha::STTr", "Alpha::reloc_gprellow", "Alpha::LDAHr", "Alpha::reloc_gprelhigh", "Alpha::LDQl", "Alpha::reloc_literal", "Alpha::LDAg", "Alpha::LDAHg", "Alpha::reloc_gpdist", "3", "\"unknown relocatable instruction\"", "Alpha::reloc_bsr", "\"ERROR: Unknown type of MachineOperand: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "const", "char", "*", "getSymbol", "(", ")", "const", "{", "return", "S", ".", "c_str", "(", ")", ";", "}", "</s>" ]

[ "Get", "the", "target", "address", "and", "flags", "for", "the", "named", "symbol", "." ]

[ "ARM" ]

[]

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

[ "Returns", "the", "physical", "register", "reserved", "for", "use", "as", "the", "resource", "descriptor", "for", "scratch", "accesses", "." ]

[ "AMDGPU" ]

[]

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

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

[ "RI5CY", "RISCV" ]

[]