docz1105/ComBack · Datasets at Hugging Face

ground_truth sequencelengths 8 512	natrual_language sequencelengths 1 243	TS_V_token sequencelengths 1 182	File stringlengths 2 45	Func stringlengths 1 56	Target stringclasses 175 values	Target_Clf stringclasses 6 values	Compiler_Type stringclasses 2 values	Idx int64 0 36.2k	Length int64 6 510	Cover_Rate float64 1 1	Template_token sequencelengths 0 0
[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "AMDGPUSubtarget", "::", "getWavesPerEU", "(", "const", "Function", "&", "F", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Default", "(", "1", ",", "getMaxWavesPerEU", "(", ")", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "FlatWorkGroupSizes", "=", "getFlatWorkGroupSizes", "(", "F", ")", ";", "unsigned", "MinImpliedByFlatWorkGroupSize", "=", "getMaxWavesPerEU", "(", "FlatWorkGroupSizes", ".", "second", ")", ";", "bool", "RequestedFlatWorkGroupSize", "=", "false", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-max-work-group-size\"", ")", "\|\|", "F", ".", "hasFnAttribute", "(", "\"amdgpu-flat-work-group-size\"", ")", ")", "{", "Default", ".", "first", "=", "MinImpliedByFlatWorkGroupSize", ";", "RequestedFlatWorkGroupSize", "=", "true", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Requested", "=", "AMDGPU", "::", "getIntegerPairAttribute", "(", "F", ",", "\"amdgpu-waves-per-eu\"", ",", "Default", ",", "true", ")", ";", "if", "(", "Requested", ".", "second", "&&", "Requested", ".", "first", ">", "Requested", ".", "second", ")", "return", "Default", ";", "if", "(", "Requested", ".", "first", "<", "getMinWavesPerEU", "(", ")", "\|\|", "Requested", ".", "first", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "Requested", ".", "second", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "RequestedFlatWorkGroupSize", "&&", "Requested", ".", "first", ">", "MinImpliedByFlatWorkGroupSize", ")", "return", "Default", ";", "return", "Requested", ";", "}", "</s>" ]	[ "Overload", "which", "uses", "the", "specified", "values", "for", "the", "flat", "work", "group", "sizes", ",", "rather", "than", "querying", "the", "function", "itself", "." ]	[ "AMDGPU", "AMDGPU", "1", "\"amdgpu-max-work-group-size\"", "\"amdgpu-flat-work-group-size\"", "AMDGPU::getIntegerPairAttribute", "\"amdgpu-waves-per-eu\"" ]	AMDGPUSubtarget10	getWavesPerEU	AMDGPU	GPU	LLVM	16,500	185	1	[]
[ "<s>", "bool", "ARMTargetLowering", "::", "canCombineStoreAndExtract", "(", "Type", "", "VectorTy", ",", "Value", "", "Idx", ",", "unsigned", "&", "Cost", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "false", ";", "if", "(", "VectorTy", "->", "isFPOrFPVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isa", "<", "ConstantInt", ">", "(", "Idx", ")", ")", "return", "false", ";", "assert", "(", "VectorTy", "->", "isVectorTy", "(", ")", "&&", "\"VectorTy is not a vector type\"", ")", ";", "unsigned", "BitWidth", "=", "VectorTy", "->", "getPrimitiveSizeInBits", "(", ")", ".", "getFixedSize", "(", ")", ";", "if", "(", "BitWidth", "==", "64", "\|\|", "BitWidth", "==", "128", ")", "{", "Cost", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]	[ "Return", "true", "if", "the", "target", "can", "combine", "store", "(", "extractelement", "VectorTy", ",", "Idx", ")", "." ]	[ "ARM", "ARM", "\"VectorTy is not a vector type\"", "64", "128", "0" ]	ARMISelLowering (2)5	canCombineStoreAndExtract	ARM	CPU	LLVM	16,501	103	1	[]
[ "<s>", "int", "ix86_data_alignment", "(", "tree", "type", ",", "int", "align", ",", "bool", "opt", ")", "{", "int", "max_align_compat", "=", "MIN", "(", "256", ",", "MAX_OFILE_ALIGNMENT", ")", ";", "int", "max_align", "=", "MIN", "(", "(", "unsigned", ")", "ix86_tune_cost", "->", "prefetch_block", "*", "8", ",", "MAX_OFILE_ALIGNMENT", ")", ";", "if", "(", "max_align", "<", "BITS_PER_WORD", ")", "max_align", "=", "BITS_PER_WORD", ";", "switch", "(", "ix86_align_data_type", ")", "{", "case", "ix86_align_data_type_abi", ":", "opt", "=", "false", ";", "break", ";", "case", "ix86_align_data_type_compat", ":", "max_align", "=", "BITS_PER_WORD", ";", "break", ";", "case", "ix86_align_data_type_cacheline", ":", "break", ";", "}", "if", "(", "TARGET_IAMCU", ")", "align", "=", "iamcu_alignment", "(", "type", ",", "align", ")", ";", "if", "(", "opt", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", ")", "{", "if", "(", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "max_align_compat", ")", "&&", "align", "<", "max_align_compat", ")", "align", "=", "max_align_compat", ";", "if", "(", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "max_align", ")", "&&", "align", "<", "max_align", ")", "align", "=", "max_align", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "(", "opt", "?", "AGGREGATE_TYPE_P", "(", "type", ")", ":", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "128", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "if", "(", "!", "opt", ")", "return", "align", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "\|\|", "TYPE_MODE", "(", "type", ")", "==", "TCmode", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "\|\|", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "\|\|", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{", "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "\|\|", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "\|\|", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "return", "align", ";", "}", "</s>" ]	[ "Compute", "the", "alignment", "for", "a", "static", "variable", ".", "TYPE", "is", "the", "data", "type", ",", "and", "ALIGN", "is", "the", "alignment", "that", "the", "object", "would", "ordinarily", "have", ".", "The", "value", "of", "this", "function", "is", "used", "instead", "of", "that", "alignment", "to", "align", "the", "object", "." ]	[ "i386", "256", "8", "128", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128" ]	i3865	ix86_data_alignment	i386	CPU	GCC	16,502	466	1	[]
[ "<s>", "unsigned", "getNumberOfRegisters", "(", "unsigned", "ClassID", ")", "const", "{", "bool", "Vector", "=", "(", "ClassID", "==", "1", ")", ";", "if", "(", "Vector", ")", "{", "if", "(", "ST", "->", "hasNEON", "(", ")", ")", "return", "16", ";", "if", "(", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "8", ";", "return", "0", ";", "}", "if", "(", "ST", "->", "isThumb1Only", "(", ")", ")", "return", "8", ";", "return", "13", ";", "}", "</s>" ]	[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]	[ "ARM", "1", "16", "8", "0", "8", "13" ]	ARMTargetTransformInfo (2)1	getNumberOfRegisters	ARM	CPU	LLVM	16,503	63	1	[]
[ "<s>", "static", "void", "nios2_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "", "pretend_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "cumulative_args_t", "local_cum_v", "=", "pack_cumulative_args", "(", "&", "local_cum", ")", ";", "int", "regs_to_push", ";", "int", "pret_size", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "local_cum", "=", "", "cum", ";", "nios2_function_arg_advance", "(", "local_cum_v", ",", "mode", ",", "type", ",", "true", ")", ";", "regs_to_push", "=", "NUM_ARG_REGS", "-", "local_cum", ".", "regs_used", ";", "if", "(", "!", "TARGET_HAS_CDX", "&&", "!", "second_time", "&&", "regs_to_push", ">", "0", ")", "{", "rtx", "ptr", "=", "virtual_incoming_args_rtx", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "regs_used", "+", "FIRST_ARG_REGNO", ",", "mem", ",", "regs_to_push", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "pret_size", "=", "regs_to_push", "", "UNITS_PER_WORD", ";", "if", "(", "pret_size", ")", "*", "pretend_size", "=", "pret_size", ";", "}", "</s>" ]	[ "TODO", ":", "It", "may", "be", "possible", "to", "eliminate", "the", "copyback", "and", "implement", "own", "va_arg", "type", "." ]	[ "nios2", "1", "0" ]	nios23	nios2_setup_incoming_varargs	nios2	MPU	GCC	16,504	152	1	[]
[ "<s>", "TargetPassConfig", "", "TeakTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "TeakPassConfig", "(", "", "this", ",", "PM", ")", ";", "}", "</s>" ]	[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]	[ "Teak", "Teak", "Teak" ]	TeakTargetMachine	createPassConfig	Teak	DSP	LLVM	16,505	22	1	[]
[ "<s>", "static", "void", "AnalyzeArguments", "(", "CCState", "&", "State", ",", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "ArgLocs", ",", "const", "SmallVectorImpl", "<", "ArgT", ">", "&", "Args", ")", "{", "static", "const", "MCPhysReg", "RegList", "[", "]", "=", "{", "CJG", "::", "R24", ",", "CJG", "::", "R25", ",", "CJG", "::", "R26", ",", "CJG", "::", "R27", ",", "CJG", "::", "R28", ",", "CJG", "::", "R29", ",", "CJG", "::", "R30", ",", "CJG", "::", "R31", "}", ";", "static", "const", "unsigned", "NbRegs", "=", "array_lengthof", "(", "RegList", ")", ";", "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{", "llvm_unreachable", "(", "\"Cannot support var args\"", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "4", ">", "ArgsParts", ";", "ParseFunctionArgs", "(", "Args", ",", "ArgsParts", ")", ";", "unsigned", "RegsLeft", "=", "NbRegs", ";", "bool", "UseStack", "=", "false", ";", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Args", "[", "ValNo", "]", ".", "Flags", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "4", ",", "4", ",", "ArgFlags", ")", ";", "continue", ";", "}", "unsigned", "Parts", "=", "ArgsParts", "[", "i", "]", ";", "if", "(", "!", "UseStack", "&&", "Parts", "<=", "RegsLeft", ")", "{", "unsigned", "FirstVal", "=", "ValNo", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", "++", ",", "ArgVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "RegsLeft", "--", ";", "}", "SmallVectorImpl", "<", "CCValAssign", ">", "::", "iterator", "B", "=", "ArgLocs", ".", "begin", "(", ")", "+", "FirstVal", ";", "std", "::", "reverse", "(", "B", ",", "B", "+", "Parts", ")", ";", "}", "else", "{", "UseStack", "=", "true", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "CC_CJG", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "ArgFlags", ",", "State", ")", ";", "}", "}", "}", "</s>" ]	[ "The", "function", "will", "invoke", "AnalyzeCallOperands", "." ]	[ "CJG", "CJG::R24", "CJG::R25", "CJG::R26", "CJG::R27", "CJG::R28", "CJG::R29", "CJG::R30", "CJG::R31", "\"Cannot support var args\"", "4", "0", "0", "ISD::ArgFlagsTy", "4", "4", "0", "0", "CJG" ]	CJGISelLowering	AnalyzeArguments	CJG	CPU	LLVM	16,506	351	1	[]
[ "<s>", "int", "HexagonInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "auto", "&", "RI", "=", "getRegisterInfo", "(", ")", ";", "MachineOperand", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "if", "(", "RI", ".", "isPhysicalRegister", "(", "DefMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "DefMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "DefMO", ".", "getReg", "(", ")", ",", "&", "RI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "DefMI", ".", "findRegisterDefOperandIdx", "(", "", "SR", ",", "false", ",", "false", ",", "&", "RI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "DefIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "MachineOperand", "UseMO", "=", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ";", "if", "(", "UseMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "UseMO", ".", "getReg", "(", ")", ",", "&", "RI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "UseMI", ".", "findRegisterUseOperandIdx", "(", "*", "SR", ",", "false", ",", "&", "RI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "UseIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "}", "return", "TargetInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "}", "</s>" ]	[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]	[ "Hexagon", "Hexagon", "1", "1" ]	HexagonInstrInfo10	getOperandLatency	Hexagon	DSP	LLVM	16,507	224	1	[]
[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "HexagonArchEnum", ">", "CpuTable", "{", "{", "\"hexagonv4\"", ",", "V4", "}", ",", "{", "\"hexagonv5\"", ",", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "V62", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVXOps", "=", "false", ";", "UseHVXDblOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseMemOps", "=", "DisableMemOps", "?", "false", ":", "EnableMemOps", ";", "ModeIEEERndNear", "=", "EnableIEEERndNear", ";", "UseBSBScheduling", "=", "hasV60TOps", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "EnableHexagonHVX", ".", "getPosition", "(", ")", ")", "UseHVXOps", "=", "EnableHexagonHVX", ";", "if", "(", "EnableHexagonHVXDouble", ".", "getPosition", "(", ")", ")", "UseHVXDblOps", "=", "EnableHexagonHVXDouble", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "return", "*", "this", ";", "}", "</s>" ]	[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]	[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"hexagonv4\"", "\"hexagonv5\"", "\"hexagonv55\"", "\"hexagonv60\"", "\"hexagonv62\"", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]	HexagonSubtarget12	initializeSubtargetDependencies	Hexagon	DSP	LLVM	16,508	168	1	[]
[ "<s>", "static", "void", "or1k_output_mi_thunk", "(", "FILE", "", "file", ",", "tree", "thunk_fndecl", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "epilogue_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "4", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "3", ")", ";", "if", "(", "delta", ")", "{", "rtx", "delta_rtx", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "satisfies_constraint_I", "(", "delta_rtx", ")", ")", "{", "rtx", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "PE_TMP_REGNUM", ")", ";", "emit_move_insn", "(", "scratch", ",", "delta_rtx", ")", ";", "delta_rtx", "=", "scratch", ";", "}", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "delta_rtx", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "PE_TMP_REGNUM", ")", ";", "HOST_WIDE_INT", "lo", "=", "sext_hwi", "(", "vcall_offset", ",", "16", ")", ";", "HOST_WIDE_INT", "hi", "=", "vcall_offset", "-", "lo", ";", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ";", "emit_move_insn", "(", "scratch", ",", "tmp", ")", ";", "if", "(", "hi", "!=", "0", ")", "{", "rtx", "scratch2", "=", "gen_rtx_REG", "(", "Pmode", ",", "RV_REGNUM", ")", ";", "emit_move_insn", "(", "scratch2", ",", "GEN_INT", "(", "hi", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "scratch", ",", "scratch2", ")", ")", ";", "}", "tmp", "=", "plus_constant", "(", "Pmode", ",", "scratch", ",", "lo", ")", ";", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ";", "emit_move_insn", "(", "scratch", ",", "tmp", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "scratch", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "gcc_assert", "(", "SYMBOL_REF_LOCAL_P", "(", "funexp", ")", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "emit_barrier", "(", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "epilogue_completed", "=", "0", ";", "}", "</s>" ]	[ "Worker", "for", "TARGET_ASM_OUTPUT_MI_THUNK", ".", "Output", "the", "assembler", "code", "for", "a", "thunk", "function", ".", "THUNK_DECL", "is", "the", "declaration", "for", "the", "thunk", "function", "itself", ",", "FUNCTION", "is", "the", "decl", "for", "the", "target", "function", ".", "DELTA", "is", "an", "immediate", "constant", "offset", "to", "be", "added", "to", "THIS", ".", "If", "VCALL_OFFSET", "is", "nonzero", ",", "the", "word", "at", "address", "(", "*", "THIS", "+", "VCALL_OFFSET", ")", "should", "be", "additionally", "added", "to", "THIS", "." ]	[ "or1k", "1", "1", "4", "3", "16", "0", "1", "0", "1", "1", "1", "0", "0" ]	or1k	or1k_output_mi_thunk	or1k	CPU	GCC	16,509	402	1	[]
[ "<s>", "static", "bool", "spu_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]	[ "Similarly", "for", "vector", "modes", ".", "``", "Supported", "''", "here", "is", "less", "strict", ".", "At", "least", "some", "operations", "are", "supported", ";", "need", "to", "check", "optabs", "or", "builtins", "for", "further", "details", "." ]	[ "spu" ]	spu3	spu_vector_mode_supported_p	spu	MPU	GCC	16,510	41	1	[]
[ "<s>", "static", "bool", "mn10300_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode2", ")", "!=", "MODE_FLOAT", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode1", ")", "!=", "MODE_FLOAT", ")", "return", "false", ";", "if", "(", "TARGET_AM33", "\|\|", "mode1", "==", "mode2", "\|\|", "(", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "4", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "4", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]	[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]	[ "mn10300", "4", "4" ]	mn10300	mn10300_modes_tieable_p	mn10300	MPU	GCC	16,511	80	1	[]
[ "<s>", "bool", "SystemZTTIImpl", "::", "isLSRCostLess", "(", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C1", ",", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C2", ")", "{", "return", "std", "::", "tie", "(", "C1", ".", "Insns", ",", "C1", ".", "NumRegs", ",", "C1", ".", "AddRecCost", ",", "C1", ".", "NumIVMuls", ",", "C1", ".", "NumBaseAdds", ",", "C1", ".", "ScaleCost", ",", "C1", ".", "SetupCost", ")", "<", "std", "::", "tie", "(", "C2", ".", "Insns", ",", "C2", ".", "NumRegs", ",", "C2", ".", "AddRecCost", ",", "C2", ".", "NumIVMuls", ",", "C2", ".", "NumBaseAdds", ",", "C2", ".", "ScaleCost", ",", "C2", ".", "SetupCost", ")", ";", "}", "</s>" ]	[ "Return", "true", "if", "LSR", "cost", "of", "C1", "is", "lower", "than", "C2", "." ]	[ "SystemZ", "SystemZ" ]	SystemZTargetTransformInfo23	isLSRCostLess	SystemZ	CPU	LLVM	16,512	88	1	[]
[ "<s>", "bool", "PPCTargetLowering", "::", "enableAggressiveFMAFusion", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "\"Non-floating-point FMA?\"", ")", ";", "return", "true", ";", "}", "</s>" ]	[ "Return", "true", "if", "target", "always", "benefits", "from", "combining", "into", "FMA", "for", "a", "given", "value", "type", "." ]	[ "PowerPC", "PPC", "\"Non-floating-point FMA?\"" ]	PPCISelLowering (2)2	enableAggressiveFMAFusion	PowerPC	CPU	LLVM	16,513	25	1	[]
[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "if", "(", "AI", "->", "isFloatingPointOperation", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Nand", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", "&&", "Size", "<", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "Subtarget", "->", "outlineAtomics", "(", ")", "&&", "Size", "<", "128", ")", "{", "if", "(", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Min", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Max", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMin", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMax", ")", "{", "return", "AtomicExpansionKind", "::", "None", ";", "}", "}", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]	[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]	[ "AArch64", "AArch64", "128", "128", "128" ]	AArch64ISelLowering10	shouldExpandAtomicRMWInIR	AArch64	CPU	LLVM	16,514	153	1	[]
[ "<s>", "bool", "RISCVAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]	[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]	[ "RISCV", "RISCV" ]	RISCVAsmParser (2)1	ParseDirective	RISCV	CPU	LLVM	16,515	13	1	[]
[ "<s>", "bool", "ARM64RegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]	[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]	[ "ARM64", "ARM64" ]	ARM64RegisterInfo	requiresRegisterScavenging	ARM64	CPU	LLVM	16,516	16	1	[]
[ "<s>", "static", "const", "char", "*", "m68k_get_reloc_decoration", "(", "enum", "m68k_reloc", "reloc", ")", "{", "gcc_assert", "(", "MOTOROLA", "\|\|", "reloc", "==", "RELOC_GOT", ")", ";", "switch", "(", "reloc", ")", "{", "case", "RELOC_GOT", ":", "if", "(", "MOTOROLA", ")", "{", "if", "(", "flag_pic", "==", "1", "&&", "TARGET_68020", ")", "return", "\"@GOT.w\"", ";", "else", "return", "\"@GOT\"", ";", "}", "else", "{", "if", "(", "TARGET_68020", ")", "{", "switch", "(", "flag_pic", ")", "{", "case", "1", ":", "return", "\":w\"", ";", "case", "2", ":", "return", "\":l\"", ";", "default", ":", "return", "\"\"", ";", "}", "}", "}", "case", "RELOC_TLSGD", ":", "return", "\"@TLSGD\"", ";", "case", "RELOC_TLSLDM", ":", "return", "\"@TLSLDM\"", ";", "case", "RELOC_TLSLDO", ":", "return", "\"@TLSLDO\"", ";", "case", "RELOC_TLSIE", ":", "return", "\"@TLSIE\"", ";", "case", "RELOC_TLSLE", ":", "return", "\"@TLSLE\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]	[ "Return", "string", "for", "TLS", "relocation", "RELOC", "." ]	[ "m68k", "1", "\"@GOT.w\"", "\"@GOT\"", "1", "\":w\"", "2", "\":l\"", "\"\"", "\"@TLSGD\"", "\"@TLSLDM\"", "\"@TLSLDO\"", "\"@TLSIE\"", "\"@TLSLE\"" ]	m68k4	m68k_get_reloc_decoration	m68k	MPU	GCC	16,517	119	1	[]
[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]	[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "MSP430::PUSH16r" ]	MSP430FrameLowering (2)	spillCalleeSavedRegisters	MSP430	MPU	LLVM	16,518	175	1	[]
[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "IsLittleEndian", "(", "LittleEndian", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "}", "</s>" ]	[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]	[ "AArch64", "AArch64", "AArch64", "AArch64", "\"generic\"" ]	AArch64Subtarget41	AArch64Subtarget	AArch64	CPU	LLVM	16,519	108	1	[]
[ "<s>", "static", "bool", "s390_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "if", "(", "TARGET_TPF_PROFILING", ")", "return", "false", ";", "if", "(", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "decl", "&&", "TREE_PUBLIC", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TREE_OPERAND", "(", "exp", ",", "1", ")", "&&", "s390_call_saved_register_used", "(", "TREE_OPERAND", "(", "exp", ",", "1", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]	[ "Return", "true", "if", "the", "given", "call", "expression", "can", "be", "turned", "into", "a", "sibling", "call", ".", "DECL", "holds", "the", "declaration", "of", "the", "function", "to", "be", "called", "whereas", "EXP", "is", "the", "call", "expression", "itself", "." ]	[ "s390", "1", "1" ]	s3903	s390_function_ok_for_sibcall	s390	MPU	GCC	16,520	61	1	[]
[ "<s>", "const", "char", "", "output_call", "(", "rtx", "", "operands", ")", "{", "gcc_assert", "(", "!", "arm_arch5t", ")", ";", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "LR_REGNUM", ")", "{", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "IP_REGNUM", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %\|lr\"", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "\"mov%?\\t%\|lr, %\|pc\"", ",", "operands", ")", ";", "if", "(", "TARGET_INTERWORK", "\|\|", "arm_arch4t", ")", "output_asm_insn", "(", "\"bx%?\\t%0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov%?\\t%\|pc, %0\"", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]	[ "INSN", "is", "either", "a", "function", "call", "or", "a", "millicode", "call", ".", "It", "may", "have", "an", "unconditional", "jump", "in", "its", "delay", "slot", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]	[ "arm", "0", "0", "\"mov%?\\t%0, %\|lr\"", "\"mov%?\\t%\|lr, %\|pc\"", "\"bx%?\\t%0\"", "\"mov%?\\t%\|pc, %0\"", "\"\"" ]	arm	output_call	arm	CPU	GCC	16,521	81	1	[]
[ "<s>", "static", "void", "riscv_disqualify_components", "(", "sbitmap", ",", "edge", ",", "sbitmap", ",", "bool", ")", "{", "}", "</s>" ]	[ "Implement", "TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS", "." ]	[ "riscv" ]	riscv1	riscv_disqualify_components	riscv	CPU	GCC	16,522	14	1	[]
[ "<s>", "void", "AArch64CondBrTuning", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]	[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]	[ "AArch64", "AArch64" ]	AArch64CondBrTuning	getAnalysisUsage	AArch64	CPU	LLVM	16,523	25	1	[]
[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalInterleavedAccessType", "(", "VectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "unsigned", "ElSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", "->", "getElementType", "(", ")", ")", ";", "if", "(", "VecTy", "->", "getElementType", "(", ")", "->", "isHalfTy", "(", ")", ")", "return", "false", ";", "if", "(", "VecTy", "->", "getNumElements", "(", ")", "<", "2", ")", "return", "false", ";", "if", "(", "ElSize", "!=", "8", "&&", "ElSize", "!=", "16", "&&", "ElSize", "!=", "32", ")", "return", "false", ";", "return", "VecSize", "==", "64", "\|\|", "VecSize", "%", "128", "==", "0", ";", "}", "</s>" ]	[ "Returns", "whether", "or", "not", "generating", "a", "interleaved", "load/store", "intrinsic", "for", "this", "type", "will", "be", "legal", "." ]	[ "ARM", "ARM", "2", "8", "16", "32", "64", "128", "0" ]	ARMISelLowering (3)	isLegalInterleavedAccessType	ARM	CPU	LLVM	16,524	97	1	[]
[ "<s>", "void", "avr_final_prescan_insn", "(", "rtx_insn", "", "insn", ",", "rtx", "", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: cost = %d. /\\n\"", ",", "set_src_cost", "(", "SET_SRC", "(", "set", ")", ",", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"/ DEBUG: pattern-cost = %d. */\\n\"", ",", "rtx_cost", "(", "PATTERN", "(", "insn", ")", ",", "VOIDmode", ",", "INSN", ",", "0", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "}", "if", "(", "avr_log", ".", "insn_addresses", ")", "fprintf", "(", "asm_out_file", ",", "\";; ADDR = %d\\n\"", ",", "(", "int", ")", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "}", "</s>" ]	[ "Output", "insn", "cost", "for", "next", "insn", "." ]	[ "avr", "\"/* DEBUG: cost = %d. /\\n\"", "\"/ DEBUG: pattern-cost = %d. */\\n\"", "0", "\";; ADDR = %d\\n\"" ]	avr	avr_final_prescan_insn	avr	MPU	GCC	16,525	115	1	[]
[ "<s>", "bool", "Z80old", "::", "splitReg", "(", "unsigned", "ByteSize", ",", "unsigned", "Opc8", ",", "unsigned", "&", "RC", ",", "unsigned", "&", "LoOpc", ",", "unsigned", "&", "LoIdx", ",", "unsigned", "&", "HiOpc", ",", "unsigned", "&", "HiIdx", ",", "unsigned", "&", "HiOff", ")", "{", "switch", "(", "ByteSize", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Size!\"", ")", ";", "case", "1", ":", "RC", "=", "Z80old", "::", "RR8RegClassID", ";", "LoOpc", "=", "HiOpc", "=", "Opc8", ";", "LoIdx", "=", "HiIdx", "=", "Z80old", "::", "NoSubRegister", ";", "HiOff", "=", "0", ";", "return", "false", ";", "case", "2", ":", "RC", "=", "Z80old", "::", "R16RegClassID", ";", "LoOpc", "=", "HiOpc", "=", "Opc8", ";", "LoIdx", "=", "Z80old", "::", "sub_low", ";", "HiIdx", "=", "Z80old", "::", "sub_high", ";", "HiOff", "=", "1", ";", "return", "true", ";", "}", "}", "</s>" ]	[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]	[ "Z80old", "Z80old::splitReg", "\"Unexpected Size!\"", "1", "Z80old::RR8RegClassID", "Z80old::NoSubRegister", "0", "2", "Z80old::R16RegClassID", "Z80old::sub_low", "Z80old::sub_high", "1" ]	Z80oldInstrInfo	splitReg	Z80old	MPU	LLVM	16,526	114	1	[]
[ "<s>", "bool", "AArch64InstrInfo", "::", "isGPRZero", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "MOVZWi", ":", "case", "AArch64", "::", "MOVZXi", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid MOVZi operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "case", "AArch64", "::", "ANDWri", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", ";", "case", "AArch64", "::", "ANDXri", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", ";", "case", "TargetOpcode", "::", "COPY", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", ";", "}", "return", "false", ";", "}", "</s>" ]	[ "Does", "this", "instruction", "set", "its", "full", "destination", "register", "to", "zero", "?" ]	[ "AArch64", "AArch64", "AArch64::MOVZWi", "AArch64::MOVZXi", "1", "1", "0", "3", "2", "0", "\"invalid MOVZi operands\"", "AArch64::ANDWri", "1", "AArch64::WZR", "AArch64::ANDXri", "1", "AArch64::XZR", "1", "AArch64::WZR" ]	AArch64InstrInfo (2)1	isGPRZero	AArch64	CPU	LLVM	16,527	165	1	[]
[ "<s>", "bool", "NVPTXLowerAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "auto", "allocaInst", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "{", "Changed", "=", "true", ";", "auto", "ETy", "=", "allocaInst", "->", "getAllocatedType", "(", ")", ";", "auto", "LocalAddrTy", "=", "PointerType", "::", "get", "(", "ETy", ",", "ADDRESS_SPACE_LOCAL", ")", ";", "auto", "NewASCToLocal", "=", "new", "AddrSpaceCastInst", "(", "allocaInst", ",", "LocalAddrTy", ",", "\"\"", ")", ";", "auto", "GenericAddrTy", "=", "PointerType", "::", "get", "(", "ETy", ",", "ADDRESS_SPACE_GENERIC", ")", ";", "auto", "NewASCToGeneric", "=", "new", "AddrSpaceCastInst", "(", "NewASCToLocal", ",", "GenericAddrTy", ",", "\"\"", ")", ";", "NewASCToLocal", "->", "insertAfter", "(", "allocaInst", ")", ";", "NewASCToGeneric", "->", "insertAfter", "(", "NewASCToLocal", ")", ";", "for", "(", "Use", "&", "AllocaUse", ":", "llvm", "::", "make_early_inc_range", "(", "allocaInst", "->", "uses", "(", ")", ")", ")", "{", "auto", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "LI", "&&", "LI", "->", "getPointerOperand", "(", ")", "==", "allocaInst", "&&", "!", "LI", "->", "isVolatile", "(", ")", ")", "{", "LI", "->", "setOperand", "(", "LI", "->", "getPointerOperandIndex", "(", ")", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "auto", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "SI", "&&", "SI", "->", "getPointerOperand", "(", ")", "==", "allocaInst", "&&", "!", "SI", "->", "isVolatile", "(", ")", ")", "{", "SI", "->", "setOperand", "(", "SI", "->", "getPointerOperandIndex", "(", ")", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "auto", "GI", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "GI", "&&", "GI", "->", "getPointerOperand", "(", ")", "==", "allocaInst", ")", "{", "GI", "->", "setOperand", "(", "GI", "->", "getPointerOperandIndex", "(", ")", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "auto", "BI", "=", "dyn_cast", "<", "BitCastInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "BI", "&&", "BI", "->", "getOperand", "(", "0", ")", "==", "allocaInst", ")", "{", "BI", "->", "setOperand", "(", "0", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]	[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]	[ "NVPTX", "NVPTX", "\"\"", "\"\"", "0", "0" ]	NVPTXLowerAlloca4	runOnFunction	NVPTX	GPU	LLVM	16,528	346	1	[]
[ "<s>", "const", "MCPhysReg", "", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "return", "getDarwinCalleeSavedRegs", "(", "MF", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Win64", ")", "return", "CSR_AArch64_AAPCS_X18_SaveList", ";", "if", "(", "hasSVEArgsOrReturn", "(", "MF", ")", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]	[ "Code", "Generation", "virtual", "methods", "..." ]	[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]	AArch64RegisterInfo21	getCalleeSavedRegs	AArch64	CPU	LLVM	16,529	246	1	[]
[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "bool", "PendConditionalInstruction", "=", "false", ";", "SmallVector", "<", "NearMissInfo", ",", "4", ">", "NearMisses", ";", "MatchResult", "=", "MatchInstruction", "(", "Operands", ",", "Inst", ",", "NearMisses", ",", "MatchingInlineAsm", ",", "PendConditionalInstruction", ",", "Out", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Parsed as: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "forwardVPTPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Changed to: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", "&&", "!", "getTargetOptions", "(", ")", ".", "MCNoDeprecatedWarn", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "forwardVPTPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "PendConditionalInstruction", ")", "{", "PendingConditionalInsts", ".", "push_back", "(", "Inst", ")", ";", "if", "(", "isITBlockFull", "(", ")", "\|\|", "isITBlockTerminator", "(", "Inst", ")", ")", "flushPendingInstructions", "(", "Out", ")", ";", "}", "else", "{", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "return", "false", ";", "case", "Match_NearMisses", ":", "ReportNearMisses", "(", "NearMisses", ",", "IDLoc", ",", "Operands", ")", ";", "return", "true", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "ARMMnemonicSpellCheck", "(", "(", "(", "ARMOperand", "&", ")", "", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "ARMOperand", "&", ")", "", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]	[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]	[ "ARM", "ARM", "4", "\"Parsed as: \"", "\"\\n\"", "\"Changed to: \"", "\"\\n\"", "\"deprecated instruction in IT block\"", "ARM::ITasm", "ARM", "ARM", "0", "\"invalid instruction\"", "ARM", "0", "\"Implement any new match types added!\"" ]	ARMAsmParser127	MatchAndEmitInstruction	ARM	CPU	LLVM	16,530	388	1	[]
[ "<s>", "bool", "arc_store_addr_hazard_p", "(", "rtx_insn", "", "producer", ",", "rtx_insn", "", "consumer", ")", "{", "if", "(", "TARGET_ARC700", "&&", "(", "arc_tune", "!=", "ARC_TUNE_ARC7XX", ")", ")", "return", "true", ";", "return", "arc_store_addr_hazard_internal_p", "(", "producer", ",", "consumer", ")", ";", "}", "</s>" ]	[ "Return", "true", "if", "a", "load", "instruction", "(", "CONSUMER", ")", "uses", "the", "same", "address", "as", "a", "store", "instruction", "(", "PRODUCER", ")", ".", "This", "function", "is", "used", "to", "avoid", "st/ld", "address", "hazard", "in", "ARC700", "cores", "." ]	[ "arc" ]	arc	arc_store_addr_hazard_p	arc	MPU	GCC	16,531	34	1	[]
[ "<s>", "static", "bool", "legitimate_small_data_address_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "return", "legitimate_small_data_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_SMALL_P", "(", "x", ")", ";", "case", "PLUS", ":", "{", "bool", "p0", "=", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "bool", "p1", "=", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "g_switch_value", ")", ";", "return", "p0", "&&", "p1", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]	[ "Return", "true", "if", "x", "is", "ok", "to", "be", "used", "as", "a", "small", "data", "address", "." ]	[ "arc", "0", "0", "0", "1", "1" ]	arc8	legitimate_small_data_address_p	arc	MPU	GCC	16,532	110	1	[]
[ "<s>", "bool", "scalar_chain", "::", "build", "(", "bitmap", "candidates", ",", "unsigned", "insn_uid", ",", "bitmap", "disallowed", ")", "{", "queue", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "bitmap_set_bit", "(", "queue", ",", "insn_uid", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Building chain #%d...\\n\"", ",", "chain_id", ")", ";", "while", "(", "!", "bitmap_empty_p", "(", "queue", ")", ")", "{", "insn_uid", "=", "bitmap_first_set_bit", "(", "queue", ")", ";", "bitmap_clear_bit", "(", "queue", ",", "insn_uid", ")", ";", "bitmap_clear_bit", "(", "candidates", ",", "insn_uid", ")", ";", "if", "(", "!", "add_insn", "(", "candidates", ",", "insn_uid", ",", "disallowed", ")", ")", "{", "bitmap_ior_into", "(", "disallowed", ",", "insns", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Aborted chain #%d discovery\\n\"", ",", "chain_id", ")", ";", "BITMAP_FREE", "(", "queue", ")", ";", "return", "false", ";", "}", "}", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"Collected chain #%d...\\n\"", ",", "chain_id", ")", ";", "fprintf", "(", "dump_file", ",", "\" insns: \"", ")", ";", "dump_bitmap", "(", "dump_file", ",", "insns", ")", ";", "if", "(", "!", "bitmap_empty_p", "(", "defs_conv", ")", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "const", "char", "*", "comma", "=", "\"\"", ";", "fprintf", "(", "dump_file", ",", "\" defs to convert: \"", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "defs_conv", ",", "0", ",", "id", ",", "bi", ")", "{", "fprintf", "(", "dump_file", ",", "\"%sr%d\"", ",", "comma", ",", "id", ")", ";", "comma", "=", "\", \"", ";", "}", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "}", "BITMAP_FREE", "(", "queue", ")", ";", "return", "true", ";", "}", "</s>" ]	[ "Build", "new", "chain", "starting", "from", "insn", "INSN_UID", "recursively", "adding", "all", "dependent", "uses", "and", "definitions", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "chain", "discovery", "was", "aborted", "." ]	[ "i386", "\"Building chain #%d...\\n\"", "\"Aborted chain #%d discovery\\n\"", "\"Collected chain #%d...\\n\"", "\" insns: \"", "\"\"", "\" defs to convert: \"", "0", "\"%sr%d\"", "\", \"", "\"\\n\"" ]	i386-features1	build	i386	CPU	GCC	16,533	217	1	[]
[ "<s>", "static", "bool", "m32r_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]	[ "Worker", "function", "for", "TARGET_MODE_DEPENDENT_ADDRESS_P", "." ]	[ "m32r" ]	m32r	m32r_mode_dependent_address_p	m32r	MPU	GCC	16,534	28	1	[]
[ "<s>", "static", "void", "ix86_pad_short_function", "(", "void", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "{", "rtx_insn", "", "ret", "=", "BB_END", "(", "e", "->", "src", ")", ";", "if", "(", "JUMP_P", "(", "ret", ")", "&&", "ANY_RETURN_P", "(", "PATTERN", "(", "ret", ")", ")", ")", "{", "int", "insn_count", "=", "ix86_count_insn", "(", "e", "->", "src", ")", ";", "if", "(", "insn_count", "<", "4", ")", "{", "rtx_insn", "", "insn", "=", "ret", ";", "while", "(", "insn", "&&", "(", "!", "NOTE_P", "(", "insn", ")", "\|\|", "NOTE_KIND", "(", "insn", ")", "!=", "NOTE_INSN_EPILOGUE_BEG", ")", ")", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "if", "(", "!", "insn", ")", "insn", "=", "ret", ";", "insn_count", "=", "2", "*", "(", "4", "-", "insn_count", ")", ";", "emit_insn_before", "(", "gen_nops", "(", "GEN_INT", "(", "insn_count", ")", ")", ",", "insn", ")", ";", "}", "}", "}", "}", "</s>" ]	[ "Pad", "short", "function", "to", "4", "instructions", "." ]	[ "i386", "4", "2", "4" ]	i386	ix86_pad_short_function	i386	CPU	GCC	16,535	139	1	[]
[ "<s>", "void", "SparcAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", ";", "case", "SP", "::", "GETPCX", ":", "LowerGETPCXAndEmitMCInsts", "(", "MI", ",", "getSubtargetInfo", "(", ")", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "MCInst", "TmpInst", ";", "LowerSparcMachineInstrToMCInst", "(", "I", ",", "TmpInst", ",", "", "this", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]	[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]	[ "Sparc", "Sparc", "SP::GETPCX", "Sparc" ]	SparcAsmPrinter10	EmitInstruction	Sparc	CPU	LLVM	16,536	110	1	[]
[ "<s>", "bool", "PatmosInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "", "&", "TBB", ",", "MachineBasicBlock", "", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "assert", "(", "AllowModify", "\|\|", "(", "TBB", "==", "0", "&&", "FBB", "==", "0", "&&", "Cond", ".", "size", "(", ")", "==", "0", ")", ")", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", "\|\|", "I", "->", "isPseudo", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", "\|\|", "I", "->", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "!", "isPredicated", "(", "", "I", ")", ")", "{", "if", "(", "!", "I", "->", "isUnconditionalBranch", "(", ")", ")", "fixOpcodeForGuard", "(", "", "I", ")", ";", "TBB", "=", "getBranchTarget", "(", "&", "", "I", ")", ";", "if", "(", "AllowModify", ")", "{", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "}", "continue", ";", "}", "if", "(", "isPredicated", "(", "", "I", ")", ")", "{", "if", "(", "!", "I", "->", "isConditionalBranch", "(", ")", ")", "fixOpcodeForGuard", "(", "", "I", ")", ";", "if", "(", "Cond", ".", "size", "(", ")", ">", "0", ")", "return", "true", ";", "int", "i", "=", "I", "->", "findFirstPredOperandIdx", "(", ")", ";", "assert", "(", "i", "!=", "-", "1", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", "+", "1", ")", ")", ";", "if", "(", "TBB", ")", "FBB", "=", "TBB", ";", "TBB", "=", "getBranchTarget", "(", "&", "*", "I", ")", ";", "continue", ";", "}", "llvm_unreachable", "(", "\"AnalyzeBranch error.\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]	[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]	[ "Patmos", "Patmos", "0", "0", "0", "0", "1", "1", "\"AnalyzeBranch error.\"" ]	PatmosInstrInfo1	analyzeBranch	Patmos	VLIW	LLVM	16,537	301	1	[]
[ "<s>", "static", "void", "frame_related_constant_load", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "constant", ",", "bool", "related", ")", "{", "rtx", "insn", ";", "rtx", "cst", "=", "GEN_INT", "(", "constant", ")", ";", "if", "(", "constant", ">=", "-", "32768", "&&", "constant", "<", "65536", ")", "insn", "=", "emit_move_insn", "(", "reg", ",", "cst", ")", ";", "else", "{", "insn", "=", "emit_insn", "(", "gen_movsi_high", "(", "reg", ",", "cst", ")", ")", ";", "if", "(", "related", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_movsi_low", "(", "reg", ",", "reg", ",", "cst", ")", ")", ";", "}", "if", "(", "related", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]	[ "Emit", "code", "to", "load", "a", "constant", "CONSTANT", "into", "register", "REG", ";", "setting", "RTX_FRAME_RELATED_P", "on", "all", "insns", "we", "generate", "if", "RELATED", "is", "true", ".", "Make", "sure", "that", "the", "insns", "we", "generate", "need", "not", "be", "split", "." ]	[ "bfin", "32768", "65536", "1", "1" ]	bfin2	frame_related_constant_load	bfin	DSP	GCC	16,538	97	1	[]
[ "<s>", "static", "bool", "rs6000_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "mode", "==", "TFmode", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 long double\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "!", "type", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "int_size_in_bytes", "(", "type", ")", "<", "0", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: variable size\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: AltiVec\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_pass_big_vectors", "=", "false", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: synthetic vector\\n\"", ")", ";", "if", "(", "!", "warned_for_pass_big_vectors", ")", "{", "warning", "(", "0", ",", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", ")", ";", "warned_for_pass_big_vectors", "=", "true", ";", "}", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]	[ "A", "C", "expression", "that", "indicates", "when", "an", "argument", "must", "be", "passed", "by", "reference", ".", "If", "nonzero", "for", "an", "argument", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", ".", "The", "pointer", "is", "passed", "in", "whatever", "way", "is", "appropriate", "for", "passing", "a", "pointer", "to", "that", "type", ".", "Under", "V.4", ",", "aggregates", "and", "long", "double", "are", "passed", "by", "reference", ".", "As", "an", "extension", "to", "all", "32-bit", "ABIs", ",", "AltiVec", "vectors", "are", "passed", "by", "reference", "unless", "the", "AltiVec", "vector", "extension", "ABI", "is", "in", "force", ".", "As", "an", "extension", "to", "all", "ABIs", ",", "variable", "sized", "types", "are", "passed", "by", "reference", "." ]	[ "rs6000", "\"function_arg_pass_by_reference: V4 long double\\n\"", "1", "0", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", "1", "0", "\"function_arg_pass_by_reference: variable size\\n\"", "1", "\"function_arg_pass_by_reference: AltiVec\\n\"", "1", "16", "8", "\"function_arg_pass_by_reference: synthetic vector\\n\"", "0", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", "1", "0" ]	rs60004	rs6000_pass_by_reference	rs6000	CPU	GCC	16,539	202	1	[]
[ "<s>", "tree", "resolve_overloaded_builtin", "(", "location_t", "location", ",", "unsigned", "int", "code", ",", "vec", "<", "tree", ",", "va_gc", ">", "", "arglist", ")", "{", "if", "(", "code", ">=", "vec_safe_length", "(", "registered_functions", ")", ")", "return", "NULL_TREE", ";", "registered_function", "&", "rfn", "=", "", "(", "", "registered_functions", ")", "[", "code", "]", ";", "if", "(", "rfn", ".", "overloaded_p", ")", "return", "function_resolver", "(", "location", ",", "rfn", ".", "instance", ",", "rfn", ".", "decl", ",", "", "arglist", ")", ".", "resolve", "(", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]	[ "If", "we", "'re", "implementing", "manual", "overloading", ",", "check", "whether", "the", "SVE", "function", "with", "subcode", "CODE", "is", "overloaded", ",", "and", "if", "so", "attempt", "to", "determine", "the", "corresponding", "non-overloaded", "function", ".", "The", "call", "occurs", "at", "location", "LOCATION", "and", "has", "the", "arguments", "given", "by", "ARGLIST", ".", "If", "the", "call", "is", "erroneous", ",", "report", "an", "appropriate", "error", "and", "return", "error_mark_node", ".", "Otherwise", ",", "if", "the", "function", "is", "overloaded", ",", "return", "the", "decl", "of", "the", "non-overloaded", "function", ".", "Return", "NULL_TREE", "otherwise", ",", "indicating", "that", "the", "call", "should", "be", "processed", "in", "the", "normal", "way", "." ]	[ "aarch64" ]	aarch64-sve-builtins	resolve_overloaded_builtin	aarch64	CPU	GCC	16,540	76	1	[]
[ "<s>", "const", "SystemZSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]	[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]	[ "SystemZ", "SystemZ" ]	SystemZTargetMachine10	getSubtargetImpl	SystemZ	CPU	LLVM	16,541	17	1	[]
[ "<s>", "static", "void", "rs6000_emit_dot_insn", "(", "rtx", "dst", ",", "rtx", "src", ",", "int", "dot", ",", "rtx", "ccreg", ")", "{", "if", "(", "dot", "==", "0", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "return", ";", "}", "if", "(", "cc_reg_not_cr0_operand", "(", "ccreg", ",", "CCmode", ")", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_move_insn", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "dst", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "rtx", "ccset", "=", "gen_rtx_SET", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src", ",", "const0_rtx", ")", ")", ";", "if", "(", "dot", "==", "1", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "dst", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "clobber", ")", ")", ")", ";", "}", "else", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "set", ")", ")", ")", ";", "}", "}", "</s>" ]	[ "Emit", "a", "potentially", "record-form", "instruction", ",", "setting", "DST", "from", "SRC", ".", "If", "DOT", "is", "0", ",", "that", "is", "all", ";", "otherwise", ",", "set", "CCREG", "to", "the", "result", "of", "the", "signed", "comparison", "of", "DST", "with", "zero", ".", "If", "DOT", "is", "1", ",", "the", "generated", "RTL", "does", "n't", "care", "about", "the", "DST", "result", ";", "if", "DOT", "is", "2", ",", "it", "does", ".", "If", "CCREG", "is", "CR0", "do", "a", "single", "dot", "insn", "(", "as", "a", "PARALLEL", ")", ";", "otherwise", ",", "do", "a", "SET", "and", "a", "separate", "COMPARE", "." ]	[ "rs6000", "0", "1", "2", "2" ]	rs60005	rs6000_emit_dot_insn	rs6000	CPU	GCC	16,542	151	1	[]
[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitHeader", "(", "Module", "&", "M", ",", "raw_ostream", "&", "O", ",", "const", "NVPTXSubtarget", "&", "STI", ")", "{", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"// Generated by LLVM NVPTX Back-End\\n\"", ";", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"\\n\"", ";", "unsigned", "PTXVersion", "=", "STI", ".", "getPTXVersion", "(", ")", ";", "O", "<<", "\".version \"", "<<", "(", "PTXVersion", "/", "10", ")", "<<", "\".\"", "<<", "(", "PTXVersion", "%", "10", ")", "<<", "\"\\n\"", ";", "O", "<<", "\".target \"", ";", "O", "<<", "STI", ".", "getTargetName", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "if", "(", "NTM", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "NVCL", ")", "O", "<<", "\", texmode_independent\"", ";", "bool", "HasFullDebugInfo", "=", "false", ";", "for", "(", "DICompileUnit", "*", "CU", ":", "M", ".", "debug_compile_units", "(", ")", ")", "{", "switch", "(", "CU", "->", "getEmissionKind", "(", ")", ")", "{", "case", "DICompileUnit", "::", "NoDebug", ":", "case", "DICompileUnit", "::", "DebugDirectivesOnly", ":", "break", ";", "case", "DICompileUnit", "::", "LineTablesOnly", ":", "case", "DICompileUnit", "::", "FullDebug", ":", "HasFullDebugInfo", "=", "true", ";", "break", ";", "}", "if", "(", "HasFullDebugInfo", ")", "break", ";", "}", "if", "(", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", "&&", "HasFullDebugInfo", ")", "O", "<<", "\", debug\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\".address_size \"", ";", "if", "(", "NTM", ".", "is64Bit", "(", ")", ")", "O", "<<", "\"64\"", ";", "else", "O", "<<", "\"32\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]	[ "Emit", "the", "header", "for", "this", "unit", ",", "not", "including", "the", "initial", "length", "field", "." ]	[ "NVPTX", "NVPTX", "NVPTX", "\"//\\n\"", "\"// Generated by LLVM NVPTX Back-End\\n\"", "\"//\\n\"", "\"\\n\"", "\".version \"", "10", "\".\"", "10", "\"\\n\"", "\".target \"", "NVPTX", "NVPTX", "NVPTX::NVCL", "\", texmode_independent\"", "\", debug\"", "\"\\n\"", "\".address_size \"", "\"64\"", "\"32\"", "\"\\n\"", "\"\\n\"" ]	NVPTXAsmPrinter15	emitHeader	NVPTX	GPU	LLVM	16,543	220	1	[]
[ "<s>", "bool", "X86DiscriminateMemOps", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "EnableDiscriminateMemops", ")", "return", "false", ";", "DISubprogram", "", "FDI", "=", "MF", ".", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "if", "(", "!", "FDI", "\|\|", "!", "FDI", "->", "getUnit", "(", ")", "->", "getDebugInfoForProfiling", "(", ")", ")", "return", "false", ";", "const", "DILocation", "", "ReferenceDI", "=", "DILocation", "::", "get", "(", "FDI", "->", "getContext", "(", ")", ",", "FDI", "->", "getLine", "(", ")", ",", "0", ",", "FDI", ")", ";", "DenseMap", "<", "Location", ",", "unsigned", ">", "MemOpDiscriminators", ";", "MemOpDiscriminators", "[", "diToLocation", "(", "ReferenceDI", ")", "]", "=", "0", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "const", "auto", "&", "DI", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DI", ")", "continue", ";", "Location", "Loc", "=", "diToLocation", "(", "DI", ")", ";", "MemOpDiscriminators", "[", "Loc", "]", "=", "std", "::", "max", "(", "MemOpDiscriminators", "[", "Loc", "]", ",", "DI", "->", "getBaseDiscriminator", "(", ")", ")", ";", "}", "}", "DenseMap", "<", "Location", ",", "DenseSet", "<", "unsigned", ">>", "Seen", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "X86II", "::", "getMemoryOperandNo", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ")", "<", "0", ")", "continue", ";", "const", "DILocation", "*", "DI", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DI", ")", "{", "DI", "=", "ReferenceDI", ";", "}", "Location", "L", "=", "diToLocation", "(", "DI", ")", ";", "DenseSet", "<", "unsigned", ">", "&", "Set", "=", "Seen", "[", "L", "]", ";", "const", "std", "::", "pair", "<", "DenseSet", "<", "unsigned", ">", "::", "iterator", ",", "bool", ">", "TryInsert", "=", "Set", ".", "insert", "(", "DI", "->", "getBaseDiscriminator", "(", ")", ")", ";", "if", "(", "!", "TryInsert", ".", "second", ")", "{", "unsigned", "BF", ",", "DF", ",", "CI", "=", "0", ";", "DILocation", "::", "decodeDiscriminator", "(", "DI", "->", "getDiscriminator", "(", ")", ",", "BF", ",", "DF", ",", "CI", ")", ";", "Optional", "<", "unsigned", ">", "EncodedDiscriminator", "=", "DILocation", "::", "encodeDiscriminator", "(", "MemOpDiscriminators", "[", "L", "]", "+", "1", ",", "DF", ",", "CI", ")", ";", "if", "(", "!", "EncodedDiscriminator", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unable to create a unique discriminator \"", "\"for instruction with memory operand in: \"", "<<", "DI", "->", "getFilename", "(", ")", "<<", "\" Line: \"", "<<", "DI", "->", "getLine", "(", ")", "<<", "\" Column: \"", "<<", "DI", "->", "getColumn", "(", ")", "<<", "\". This is likely due to a large macro expansion. \\n\"", ")", ";", "continue", ";", "}", "++", "MemOpDiscriminators", "[", "L", "]", ";", "DI", "=", "DI", "->", "cloneWithDiscriminator", "(", "EncodedDiscriminator", ".", "getValue", "(", ")", ")", ";", "updateDebugInfo", "(", "&", "MI", ",", "DI", ")", ";", "Changed", "=", "true", ";", "std", "::", "pair", "<", "DenseSet", "<", "unsigned", ">", "::", "iterator", ",", "bool", ">", "MustInsert", "=", "Set", ".", "insert", "(", "DI", "->", "getBaseDiscriminator", "(", ")", ")", ";", "(", "void", ")", "MustInsert", ";", "assert", "(", "MustInsert", ".", "second", "&&", "\"New discriminator shouldn't be present in set\"", ")", ";", "}", "ReferenceDI", "=", "DI", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]	[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]	[ "X86", "X86", "0", "0", "X86II::getMemoryOperandNo", "0", "0", "1", "\"Unable to create a unique discriminator \"", "\"for instruction with memory operand in: \"", "\" Line: \"", "\" Column: \"", "\". This is likely due to a large macro expansion. \\n\"", "\"New discriminator shouldn't be present in set\"" ]	X86DiscriminateMemOps (2)	runOnMachineFunction	X86	CPU	LLVM	16,544	464	1	[]
[ "<s>", "void", "aarch64_expand_call", "(", "rtx", "result", ",", "rtx", "mem", ",", "bool", "sibcall", ")", "{", "rtx", "call", ",", "callee", ",", "tmp", ";", "rtvec", "vec", ";", "machine_mode", "mode", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "callee", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "mode", "=", "GET_MODE", "(", "callee", ")", ";", "gcc_assert", "(", "mode", "==", "Pmode", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "callee", ")", "?", "(", "aarch64_is_long_call_p", "(", "callee", ")", "\|\|", "aarch64_is_noplt_call_p", "(", "callee", ")", ")", ":", "!", "REG_P", "(", "callee", ")", ")", "XEXP", "(", "mem", ",", "0", ")", "=", "force_reg", "(", "mode", ",", "callee", ")", ";", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "mem", ",", "const0_rtx", ")", ";", "if", "(", "result", "!=", "NULL_RTX", ")", "call", "=", "gen_rtx_SET", "(", "result", ",", "call", ")", ";", "if", "(", "sibcall", ")", "tmp", "=", "ret_rtx", ";", "else", "tmp", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNUM", ")", ")", ";", "vec", "=", "gen_rtvec", "(", "2", ",", "call", ",", "tmp", ")", ";", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "aarch64_emit_call_insn", "(", "call", ")", ";", "}", "</s>" ]	[ "This", "function", "is", "used", "by", "the", "call", "expanders", "of", "the", "machine", "description", ".", "RESULT", "is", "the", "register", "in", "which", "the", "result", "is", "returned", ".", "It", "'s", "NULL", "for", "``", "call", "''", "and", "``", "sibcall", "''", ".", "MEM", "is", "the", "location", "of", "the", "function", "call", ".", "SIBCALL", "indicates", "whether", "this", "function", "call", "is", "normal", "call", "or", "sibling", "call", ".", "It", "will", "generate", "different", "pattern", "accordingly", "." ]	[ "aarch64", "0", "0", "2" ]	aarch645	aarch64_expand_call	aarch64	CPU	GCC	16,545	171	1	[]
[ "<s>", "int", "ARMBaseInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "", "ItinData", ",", "SDNode", "", "DefNode", ",", "unsigned", "DefIdx", ",", "SDNode", "", "UseNode", ",", "unsigned", "UseIdx", ")", "const", "{", "if", "(", "!", "DefNode", "->", "isMachineOpcode", "(", ")", ")", "return", "1", ";", "const", "TargetInstrDesc", "&", "DefTID", "=", "get", "(", "DefNode", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "!", "ItinData", "\|\|", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "DefTID", ".", "mayLoad", "(", ")", "?", "3", ":", "1", ";", "if", "(", "!", "UseNode", "->", "isMachineOpcode", "(", ")", ")", "{", "int", "Latency", "=", "ItinData", "->", "getOperandCycle", "(", "DefTID", ".", "getSchedClass", "(", ")", ",", "DefIdx", ")", ";", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", ")", "return", "Latency", "<=", "2", "?", "1", ":", "Latency", "-", "1", ";", "else", "return", "Latency", "<=", "3", "?", "1", ":", "Latency", "-", "2", ";", "}", "const", "TargetInstrDesc", "&", "UseTID", "=", "get", "(", "UseNode", "->", "getMachineOpcode", "(", ")", ")", ";", "const", "MachineSDNode", "", "DefMN", "=", "dyn_cast", "<", "MachineSDNode", ">", "(", "DefNode", ")", ";", "unsigned", "DefAlign", "=", "!", "DefMN", "->", "memoperands_empty", "(", ")", "?", "(", "", "DefMN", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "const", "MachineSDNode", "", "UseMN", "=", "dyn_cast", "<", "MachineSDNode", ">", "(", "UseNode", ")", ";", "unsigned", "UseAlign", "=", "!", "UseMN", "->", "memoperands_empty", "(", ")", "?", "(", "*", "UseMN", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "int", "Latency", "=", "getOperandLatency", "(", "ItinData", ",", "DefTID", ",", "DefIdx", ",", "DefAlign", ",", "UseTID", ",", "UseIdx", ",", "UseAlign", ")", ";", "if", "(", "Latency", ">", "1", "&&", "(", "Subtarget", ".", "isCortexA8", "(", ")", "\|\|", "Subtarget", ".", "isCortexA9", "(", ")", ")", ")", "{", "switch", "(", "DefTID", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "LDRBrs", ":", "{", "unsigned", "ShOpVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "DefNode", "->", "getOperand", "(", "2", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "ShImm", "=", "ARM_AM", "::", "getAM2Offset", "(", "ShOpVal", ")", ";", "if", "(", "ShImm", "==", "0", "\|\|", "(", "ShImm", "==", "2", "&&", "ARM_AM", "::", "getAM2ShiftOpc", "(", "ShOpVal", ")", "==", "ARM_AM", "::", "lsl", ")", ")", "--", "Latency", ";", "break", ";", "}", "case", "ARM", "::", "t2LDRs", ":", "case", "ARM", "::", "t2LDRBs", ":", "case", "ARM", "::", "t2LDRHs", ":", "case", "ARM", "::", "t2LDRSHs", ":", "{", "unsigned", "ShAmt", "=", "cast", "<", "ConstantSDNode", ">", "(", "DefNode", "->", "getOperand", "(", "2", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "ShAmt", "==", "0", "\|\|", "ShAmt", "==", "2", ")", "--", "Latency", ";", "break", ";", "}", "}", "}", "return", "Latency", ";", "}", "</s>" ]	[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]	[ "ARM", "ARM", "1", "3", "1", "2", "1", "1", "3", "1", "2", "0", "0", "1", "ARM::LDRrs", "ARM::LDRBrs", "2", "ARM_AM::getAM2Offset", "0", "2", "ARM_AM::getAM2ShiftOpc", "ARM_AM::lsl", "ARM::t2LDRs", "ARM::t2LDRBs", "ARM::t2LDRHs", "ARM::t2LDRSHs", "2", "0", "2" ]	ARMBaseInstrInfo54	getOperandLatency	ARM	CPU	LLVM	16,546	409	1	[]
[ "<s>", "void", "MipsAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "emitAlignment", "(", "std", "::", "max", "(", "MF", "->", "getAlignment", "(", ")", ",", "MIPS_NACL_BUNDLE_ALIGN", ")", ")", ";", "if", "(", "Subtarget", "->", "inMicroMipsMode", "(", ")", ")", "{", "TS", ".", "emitDirectiveSetMicroMips", "(", ")", ";", "TS", ".", "setUsesMicroMips", "(", ")", ";", "TS", ".", "updateABIInfo", "(", "", "Subtarget", ")", ";", "}", "else", "TS", ".", "emitDirectiveSetNoMicroMips", "(", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "TS", ".", "emitDirectiveSetMips16", "(", ")", ";", "else", "TS", ".", "emitDirectiveSetNoMips16", "(", ")", ";", "TS", ".", "emitDirectiveEnt", "(", "", "CurrentFnSym", ")", ";", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "}", "</s>" ]	[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]	[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]	MipsAsmPrinter	emitFunctionEntryLabel	Mips	CPU	LLVM	16,547	113	1	[]
[ "<s>", "bool", "isFPVectorizationPotentiallyUnsafe", "(", ")", "{", "return", "!", "ST", "->", "isTargetDarwin", "(", ")", ";", "}", "</s>" ]	[ "Indicate", "that", "it", "is", "potentially", "unsafe", "to", "automatically", "vectorize", "floating-point", "operations", "because", "the", "semantics", "of", "vector", "and", "scalar", "floating-point", "semantics", "may", "differ", "." ]	[ "ARM" ]	ARMTargetTransformInfo	isFPVectorizationPotentiallyUnsafe	ARM	CPU	LLVM	16,548	14	1	[]
[ "<s>", "unsigned", "rvexFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "if", "(", "rvexFixGlobalBaseReg", ")", "return", "GlobalBaseReg", "=", "rvex", "::", "R0", ";", "const", "TargetRegisterClass", "", "RC", ";", "RC", "=", "(", "const", "TargetRegisterClass", "", ")", "&", "rvex", "::", "CPURegsRegClass", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "}", "</s>" ]	[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]	[ "rvex", "rvex", "rvex", "rvex::R0", "rvex::CPURegsRegClass" ]	rvexMachineFunction	getGlobalBaseReg	rvex	VLIW	LLVM	16,549	57	1	[]
[ "<s>", "bool", "aarch64_sve_sqadd_sqsub_immediate_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "negate_p", ")", "{", "if", "(", "!", "aarch64_sve_arith_immediate_p", "(", "mode", ",", "x", ",", "negate_p", ")", ")", "return", "false", ";", "rtx", "elt", "=", "unwrap_const_vec_duplicate", "(", "x", ")", ";", "return", "negate_p", "==", "(", "INTVAL", "(", "elt", ")", "<", "0", ")", ";", "}", "</s>" ]	[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "the", "SVE", "SQADD", "and", "SQSUB", "instructions", "when", "applied", "to", "mode", "MODE", ".", "Negate", "X", "first", "if", "NEGATE_P", "is", "true", "." ]	[ "aarch64", "0" ]	aarch64	aarch64_sve_sqadd_sqsub_immediate_p	aarch64	CPU	GCC	16,550	49	1	[]
[ "<s>", "bool", "MSP430InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "", "MBB", ".", "getParent", "(", ")", ";", "MSP430MachineFunctionInfo", "", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]	[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "0", "1", "MSP430::PUSH16r" ]	MSP430InstrInfo14	spillCalleeSavedRegisters	MSP430	MPU	LLVM	16,551	171	1	[]
[ "<s>", "bool", "MBlazePassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", ".", "add", "(", "createMBlazeDelaySlotFillerPass", "(", "getMBlazeTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]	[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]	[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]	MBlazeTargetMachine2	addPreEmitPass	MBlaze	MPU	LLVM	16,552	23	1	[]
[ "<s>", "static", "void", "ix86_store_bounds", "(", "rtx", "ptr", ",", "rtx", "slot", ",", "rtx", "bounds", ",", "rtx", "slot_no", ")", "{", "rtx", "addr", ";", "addr", "=", "ix86_get_arg_address_for_bt", "(", "slot", ",", "slot_no", ",", "stack_pointer_rtx", ")", ";", "if", "(", "!", "ptr", ")", "{", "gcc_assert", "(", "MEM_P", "(", "slot", ")", ")", ";", "ptr", "=", "copy_addr_to_reg", "(", "slot", ")", ";", "}", "gcc_assert", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "bounds", ")", ")", ")", ";", "if", "(", "!", "register_operand", "(", "bounds", ",", "BNDmode", ")", ")", "bounds", "=", "copy_to_mode_reg", "(", "BNDmode", ",", "bounds", ")", ";", "emit_insn", "(", "BNDmode", "==", "BND64mode", "?", "gen_bnd64_stx", "(", "addr", ",", "ptr", ",", "bounds", ")", ":", "gen_bnd32_stx", "(", "addr", ",", "ptr", ",", "bounds", ")", ")", ";", "}", "</s>" ]	[ "Expand", "pass", "uses", "this", "hook", "to", "store", "BOUNDS", "for", "call", "argument", "PTR", "passed", "in", "SLOT", "in", "case", "BOUNDS", "are", "not", "passed", "in", "a", "register", ".", "If", "SLOT", "is", "a", "memory", ",", "then", "BOUNDS", "are", "stored", "as", "for", "regular", "pointer", "stored", "in", "memory", ".", "PTR", "may", "be", "NULL", "in", "case", "SLOT", "is", "a", "memory", ".", "In", "such", "case", "value", "of", "PTR", "(", "if", "required", ")", "may", "be", "loaded", "from", "SLOT", ".", "If", "SLOT", "is", "NULL", "or", "a", "register", "then", "SLOT_NO", "is", "an", "integer", "constant", "holding", "number", "of", "the", "target", "dependent", "special", "slot", "which", "should", "be", "used", "to", "store", "BOUNDS", "." ]	[ "i386" ]	i3864	ix86_store_bounds	i386	CPU	GCC	16,553	109	1	[]
[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ")", ";", "}", "</s>" ]	[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]	[ "ARM", "ARM::GPRRegisterClass", "ARM::t2STRi12", "0", "ARM" ]	Thumb2InstrInfo49	storeRegToStackSlot	ARM	CPU	LLVM	16,554	126	1	[]
[ "<s>", "SDValue", "LC2200TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "analyzeOutputArgs", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "CCInfo", ",", "Outs", ",", "true", ",", "nullptr", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", ")", "{", "llvm_unreachable", "(", "\"not supported\"", ")", ";", "}", "else", "{", "Val", "=", "convertValVTToLocVT", "(", "DAG", ",", "Val", ",", "VA", ",", "DL", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "}", "const", "Function", "&", "Func", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "if", "(", "Func", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "llvm_unreachable", "(", "\"interrupts not supported\"", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "LC2200ISD", "::", "RET", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]	[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]	[ "LC2200", "LC2200", "ISD::OutputArg", "16", "4", "1", "0", "\"Can only return in registers!\"", "MVT::i32", "MVT::f64", "\"not supported\"", "1", "0", "\"interrupt\"", "\"interrupts not supported\"", "LC2200ISD::RET", "MVT::Other" ]	LC2200ISelLowering	LowerReturn	LC2200	CPU	LLVM	16,555	332	1	[]
[ "<s>", "static", "unsigned", "int", "move_elim_pass", "(", "void", ")", "{", "rtx_insn", "", "insn", ",", "", "ninsn", ";", "rtx", "prev", "=", "NULL_RTX", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "ninsn", ")", "{", "rtx", "set", ";", "ninsn", "=", "next_nonnote_nondebug_insn", "(", "insn", ")", ";", "if", "(", "(", "set", "=", "single_set", "(", "insn", ")", ")", "==", "NULL_RTX", ")", "{", "prev", "=", "NULL_RTX", ";", "continue", ";", "}", "if", "(", "prev", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "prev", ")", ",", "SET_SRC", "(", "set", ")", ")", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_SRC", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_DEST", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_SRC", "(", "set", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_DEST", "(", "set", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Delete insn %d because it is redundant\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "delete_insn", "(", "insn", ")", ";", "prev", "=", "NULL_RTX", ";", "}", "else", "prev", "=", "set", ";", "}", "if", "(", "dump_file", ")", "print_rtl_with_bb", "(", "dump_file", ",", "get_insns", "(", ")", ",", "TDF_NONE", ")", ";", "return", "0", ";", "}", "</s>" ]	[ "Redundant", "move", "elimination", "pass", ".", "Must", "be", "run", "after", "the", "basic", "block", "reordering", "pass", "for", "the", "best", "effect", "." ]	[ "rl78", "\" Delete insn %d because it is redundant\\n\"", "0" ]	rl78	move_elim_pass	rl78	MPU	GCC	16,556	184	1	[]
[ "<s>", "void", "AArch64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ",", "Mnemonic", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "LdStNInstrDesc", "", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "AArch64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "AArch64InstPrinter", "::", "printInst", "(", "MI", ",", "O", ",", "Annot", ",", "STI", ")", ";", "}", "</s>" ]	[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]	[ "AArch64", "AArch64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "AArch64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "AArch64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "AArch64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "AArch64" ]	AArch64InstPrinter1	printInst	AArch64	CPU	LLVM	16,557	331	1	[]
[ "<s>", "void", "PPCInstrInfo", "::", "genAlternativeCodeSequence", "(", "MachineInstr", "&", "Root", ",", "MachineCombinerPattern", "Pattern", ",", "SmallVectorImpl", "<", "MachineInstr", "", ">", "&", "InsInstrs", ",", "SmallVectorImpl", "<", "MachineInstr", "", ">", "&", "DelInstrs", ",", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "InstrIdxForVirtReg", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "case", "MachineCombinerPattern", "::", "REASSOC_XY_AMM_BMM", ":", "case", "MachineCombinerPattern", "::", "REASSOC_XMM_AMM_BMM", ":", "reassociateFMA", "(", "Root", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstrIdxForVirtReg", ")", ";", "break", ";", "default", ":", "TargetInstrInfo", "::", "genAlternativeCodeSequence", "(", "Root", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstrIdxForVirtReg", ")", ";", "break", ";", "}", "}", "</s>" ]	[ "When", "getMachineCombinerPatterns", "(", ")", "finds", "potential", "patterns", ",", "this", "function", "generates", "the", "instructions", "that", "could", "replace", "the", "original", "code", "sequence", "." ]	[ "PowerPC", "PPC" ]	PPCInstrInfo128	genAlternativeCodeSequence	PowerPC	CPU	LLVM	16,558	90	1	[]
[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "return", "false", ";", "}", "</s>" ]	[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]	[ "Mips" ]	MipsAsmBackend11	mayNeedRelaxation	Mips	CPU	LLVM	16,559	14	1	[]
[ "<s>", "static", "machine_mode", "aarch64_c_mode_for_suffix", "(", "char", "suffix", ")", "{", "if", "(", "suffix", "==", "'q'", ")", "return", "TFmode", ";", "return", "VOIDmode", ";", "}", "</s>" ]	[ "Target", "hook", "for", "c_mode_for_suffix", "." ]	[ "aarch64" ]	aarch64	aarch64_c_mode_for_suffix	aarch64	CPU	GCC	16,560	21	1	[]
[ "<s>", "void", "X86ATTInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "markup", "(", "\"<reg:\"", ")", "<<", "'%'", "<<", "getRegisterName", "(", "RegNo", ")", "<<", "markup", "(", "\">\"", ")", ";", "}", "</s>" ]	[ "Print", "the", "assembler", "register", "name", "." ]	[ "X86", "X86", "\"<reg:\"", "\">\"" ]	X86ATTInstPrinter (2)	printRegName	X86	CPU	LLVM	16,561	34	1	[]
[ "<s>", "unsigned", "getExplicitKernelArgOffset", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "isAmdHsaOrMesa", "(", "F", ")", "?", "0", ":", "36", ";", "}", "</s>" ]	[ "Returns", "the", "offset", "in", "bytes", "from", "the", "start", "of", "the", "input", "buffer", "of", "the", "first", "explicit", "kernel", "argument", "." ]	[ "AMDGPU", "0", "36" ]	AMDGPUSubtarget1	getExplicitKernelArgOffset	AMDGPU	GPU	LLVM	16,562	21	1	[]
[ "<s>", "void", "SparcInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", "&&", "!", "printSparcAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]	[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]	[ "Sparc", "Sparc", "Sparc" ]	SparcInstPrinter14	printInst	Sparc	CPU	LLVM	16,563	51	1	[]
[ "<s>", "unsigned", "Cpu0MCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Cpu0", "::", "fixup_Cpu0_24", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]	[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]	[ "Cpu0", "Cpu0", "\"getJumpTargetOpValue expects only expressions\"", "0", "Cpu0::fixup_Cpu0_24", "0" ]	Cpu0MCCodeEmitter1	getJumpTargetOpValue	Cpu0	CPU	LLVM	16,564	96	1	[]
[ "<s>", "static", "HOST_WIDE_INT", "mmix_static_rtx_alignment", "(", "machine_mode", "mode", ")", "{", "return", "MAX", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ",", "32", ")", ";", "}", "</s>" ]	[ "Implement", "TARGET_STATIC_RTX_ALIGNMENT", "." ]	[ "mmix", "32" ]	mmix	mmix_static_rtx_alignment	mmix	CPU	GCC	16,565	20	1	[]
[ "<s>", "const", "R600RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]	[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]	[ "AMDGPU", "R600" ]	AMDGPUSubtarget	getRegisterInfo	AMDGPU	GPU	LLVM	16,566	18	1	[]
[ "<s>", "void", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "}", "</s>" ]	[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]	[ "SPIRV" ]	SPIRVAsmBackend	relaxInstruction	SPIRV	Virtual ISA	LLVM	16,567	16	1	[]
[ "<s>", "static", "void", "arm_init_builtin", "(", "unsigned", "int", "fcode", ",", "arm_builtin_datum", "", "d", ",", "const", "char", "", "prefix", ")", "{", "bool", "print_type_signature_p", "=", "false", ";", "char", "type_signature", "[", "SIMD_MAX_BUILTIN_ARGS", "]", "=", "{", "0", "}", ";", "char", "namebuf", "[", "60", "]", ";", "tree", "ftype", "=", "NULL", ";", "tree", "fndecl", "=", "NULL", ";", "d", "->", "fcode", "=", "fcode", ";", "int", "op_num", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", "-", "1", ";", "int", "arg_num", "=", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", "?", "op_num", "+", "1", ":", "op_num", ";", "tree", "return_type", "=", "void_type_node", ",", "args", "=", "void_list_node", ";", "tree", "eltype", ";", "for", "(", ";", "op_num", ">=", "0", ";", "arg_num", "--", ",", "op_num", "--", ")", "{", "machine_mode", "op_mode", "=", "insn_data", "[", "d", "->", "code", "]", ".", "operand", "[", "op_num", "]", ".", "mode", ";", "enum", "arm_type_qualifiers", "qualifiers", "=", "d", "->", "qualifiers", "[", "arg_num", "]", ";", "if", "(", "qualifiers", "&", "qualifier_unsigned", ")", "{", "type_signature", "[", "arg_num", "]", "=", "'u'", ";", "print_type_signature_p", "=", "true", ";", "}", "else", "if", "(", "qualifiers", "&", "qualifier_poly", ")", "{", "type_signature", "[", "arg_num", "]", "=", "'p'", ";", "print_type_signature_p", "=", "true", ";", "}", "else", "type_signature", "[", "arg_num", "]", "=", "'s'", ";", "if", "(", "qualifiers", "&", "qualifier_internal", ")", "continue", ";", "if", "(", "qualifiers", "&", "qualifier_map_mode", ")", "op_mode", "=", "d", "->", "mode", ";", "if", "(", "qualifiers", "&", "qualifier_pointer", "&&", "VECTOR_MODE_P", "(", "op_mode", ")", ")", "op_mode", "=", "GET_MODE_INNER", "(", "op_mode", ")", ";", "eltype", "=", "arm_simd_builtin_type", "(", "op_mode", ",", "(", "qualifiers", "&", "qualifier_unsigned", ")", "!=", "0", ",", "(", "qualifiers", "&", "qualifier_poly", ")", "!=", "0", ")", ";", "gcc_assert", "(", "eltype", "!=", "NULL", ")", ";", "if", "(", "qualifiers", "&", "qualifier_const", ")", "eltype", "=", "build_qualified_type", "(", "eltype", ",", "TYPE_QUAL_CONST", ")", ";", "if", "(", "qualifiers", "&", "qualifier_pointer", ")", "eltype", "=", "build_pointer_type", "(", "eltype", ")", ";", "if", "(", "arg_num", "==", "0", ")", "return_type", "=", "eltype", ";", "else", "args", "=", "tree_cons", "(", "NULL_TREE", ",", "eltype", ",", "args", ")", ";", "}", "ftype", "=", "build_function_type", "(", "return_type", ",", "args", ")", ";", "gcc_assert", "(", "ftype", "!=", "NULL", ")", ";", "if", "(", "print_type_signature_p", "&&", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_VFP_BASE", ",", "ARM_BUILTIN_ACLE_BASE", "-", "1", ")", ")", "snprintf", "(", "namebuf", ",", "sizeof", "(", "namebuf", ")", ",", "\"%s_%s_%s\"", ",", "prefix", ",", "d", "->", "name", ",", "type_signature", ")", ";", "else", "snprintf", "(", "namebuf", ",", "sizeof", "(", "namebuf", ")", ",", "\"%s_%s\"", ",", "prefix", ",", "d", "->", "name", ")", ";", "fndecl", "=", "add_builtin_function", "(", "namebuf", ",", "ftype", ",", "fcode", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "arm_builtin_decls", "[", "fcode", "]", "=", "fndecl", ";", "}", "</s>" ]	[ "Set", "up", "a", "builtin", ".", "It", "will", "use", "information", "stored", "in", "the", "argument", "struct", "D", "to", "derive", "the", "builtin", "'s", "type", "signature", "and", "name", ".", "It", "will", "append", "the", "name", "in", "D", "to", "the", "PREFIX", "passed", "and", "use", "these", "to", "create", "a", "builtin", "declaration", "that", "is", "then", "stored", "in", "'arm_builtin_decls", "'", "under", "index", "FCODE", ".", "This", "FCODE", "is", "also", "written", "back", "to", "D", "for", "future", "use", "." ]	[ "arm", "0", "60", "1", "0", "1", "0", "0", "0", "0", "1", "\"%s_%s_%s\"", "\"%s_%s\"" ]	arm-builtins4	arm_init_builtin	arm	CPU	GCC	16,568	402	1	[]
[ "<s>", "std", "::", "unique_ptr", "<", "CSEConfigBase", ">", "MOSPassConfig", "::", "getCSEConfig", "(", ")", "const", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "std", "::", "make_unique", "<", "CSEConfigConstantOnly", ">", "(", ")", ";", "return", "std", "::", "make_unique", "<", "MOSCSEConfigFull", ">", "(", ")", ";", "}", "</s>" ]	[ "Returns", "the", "CSEConfig", "object", "to", "use", "for", "the", "current", "optimization", "level", "." ]	[ "MOS", "MOS", "MOS" ]	MOSTargetMachine	getCSEConfig	MOS	MPU	LLVM	16,569	46	1	[]
[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "MFI", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "if", "(", "IsVarArg", ")", "{", "MVT", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "VarargVreg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "PtrVT", ")", ")", ";", "MFI", "->", "setVarargBufferVreg", "(", "VarargVreg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VarargVreg", ",", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstant", "(", "Ins", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ")", ";", "MFI", "->", "addParam", "(", "PtrVT", ")", ";", "}", "SmallVector", "<", "MVT", ",", "4", ">", "Params", ";", "SmallVector", "<", "MVT", ",", "4", ">", "Results", ";", "ComputeSignatureVTs", "(", "MF", ".", "getFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "Params", ",", "Results", ")", ";", "for", "(", "MVT", "VT", ":", "Results", ")", "MFI", "->", "addResult", "(", "VT", ")", ";", "return", "Chain", ";", "}", "</s>" ]	[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]	[ "WebAssembly", "WebAssembly", "ISD::InputArg", "\"WebAssembly doesn't support non-C calling conventions\"", "WebAssembly", "WebAssembly::ARGUMENTS", "ISD::InputArg", "\"WebAssembly hasn't implemented inalloca arguments\"", "\"WebAssembly hasn't implemented nest arguments\"", "\"WebAssembly hasn't implemented cons regs arguments\"", "\"WebAssembly hasn't implemented cons regs last arguments\"", "WebAssemblyISD::ARGUMENT", "MVT::i32", "WebAssemblyISD::ARGUMENT", "MVT::i32", "4", "4" ]	WebAssemblyISelLowering21	LowerFormalArguments	WebAssembly	Virtual ISA	LLVM	16,570	390	1	[]
[ "<s>", "static", "bool", "expand_vselect", "(", "rtx", "target", ",", "rtx", "op0", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ",", "bool", "testing_p", ")", "{", "unsigned", "int", "i", ";", "rtx", "x", ",", "save_vconcat", ";", "int", "icode", ";", "if", "(", "vselect_insn", "==", "NULL_RTX", ")", "init_vselect_insn", "(", ")", ";", "x", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "1", ")", ";", "PUT_NUM_ELEM", "(", "XVEC", "(", "x", ",", "0", ")", ",", "nelt", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "XVECEXP", "(", "x", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "perm", "[", "i", "]", ")", ";", "save_vconcat", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", ";", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", "=", "op0", ";", "PUT_MODE", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "GET_MODE", "(", "target", ")", ")", ";", "SET_DEST", "(", "PATTERN", "(", "vselect_insn", ")", ")", "=", "target", ";", "icode", "=", "recog_memoized", "(", "vselect_insn", ")", ";", "if", "(", "icode", ">=", "0", "&&", "!", "testing_p", ")", "emit_insn", "(", "copy_rtx", "(", "PATTERN", "(", "vselect_insn", ")", ")", ")", ";", "SET_DEST", "(", "PATTERN", "(", "vselect_insn", ")", ")", "=", "const0_rtx", ";", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", "=", "save_vconcat", ";", "INSN_CODE", "(", "vselect_insn", ")", "=", "-", "1", ";", "return", "icode", ">=", "0", ";", "}", "</s>" ]	[ "Construct", "(", "set", "target", "(", "vec_select", "op0", "(", "parallel", "perm", ")", ")", ")", "and", "return", "true", "if", "that", "'s", "a", "valid", "instruction", "in", "the", "active", "ISA", "." ]	[ "i386", "1", "0", "0", "0", "0", "0", "0", "0", "1", "0" ]	i386-expand	expand_vselect	i386	CPU	GCC	16,571	224	1	[]
[ "<s>", "void", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIV", ":", "{", "DebugLoc", "Empty", ";", "const", "DebugLoc", "&", "DL", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "if", "(", "DL", "!=", "Empty", ")", "errs", "(", ")", "<<", "\"Error at line \"", "<<", "DL", ".", "getLine", "(", ")", "<<", "\": \"", ";", "else", "errs", "(", ")", "<<", "\"Error: \"", ";", "errs", "(", ")", "<<", "\"Unsupport signed division for DAG: \"", ";", "Node", "->", "print", "(", "errs", "(", ")", ",", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"Please convert to unsigned div/mod.\\n\"", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "bpf_load_byte", ":", "case", "Intrinsic", "::", "bpf_load_half", ":", "case", "Intrinsic", "::", "bpf_load_word", ":", "{", "SDLoc", "DL", "(", "Node", ")", ";", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Skb", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "SDValue", "N3", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "R6Reg", "=", "CurDAG", "->", "getRegister", "(", "BPF", "::", "R6", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "DL", ",", "R6Reg", ",", "Skb", ",", "SDValue", "(", ")", ")", ";", "Node", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Chain", ",", "N1", ",", "R6Reg", ",", "N3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]	[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]	[ "BPF", "BPF", "\"== \"", "ISD::SDIV", "\"Error at line \"", "\": \"", "\"Error: \"", "\"Unsupport signed division for DAG: \"", "\"Please convert to unsigned div/mod.\\n\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::bpf_load_byte", "Intrinsic::bpf_load_half", "Intrinsic::bpf_load_word", "0", "1", "2", "3", "BPF::R6", "MVT::i64", "ISD::FrameIndex", "0", "BPF::MOV_rr" ]	BPFISelDAGToDAG12	Select	BPF	Virtual ISA	LLVM	16,572	393	1	[]
[ "<s>", "enum", "direction", "function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "type", "!=", "0", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "upward", ";", "return", "DEFAULT_FUNCTION_ARG_PADDING", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]	[ "Handle", "the", "FUNCTION_ARG_PADDING", "macro", ".", "For", "the", "64", "bit", "ABI", "structs", "are", "always", "stored", "left", "shifted", "in", "their", "argument", "slot", "." ]	[ "sparc", "0" ]	sparc4	function_arg_padding	sparc	CPU	GCC	16,573	36	1	[]
[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "PPCHazardRecognizer970", "::", "getHazardType", "(", "SUnit", "", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"PPC hazards don't support scoreboard lookahead\"", ")", ";", "const", "SDNode", "", "Node", "=", "SU", "->", "getNode", "(", ")", "->", "getGluedMachineNode", "(", ")", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Node", "->", "getOpcode", "(", ")", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", "NoHazard", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "NumIssued", "!=", "0", "&&", "(", "isFirst", "\|\|", "isSingle", ")", ")", "return", "Hazard", ";", "if", "(", "isCracked", "&&", "NumIssued", ">", "2", ")", "return", "Hazard", ";", "switch", "(", "InstrType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction type!\"", ")", ";", "case", "PPCII", "::", "PPC970_FXU", ":", "case", "PPCII", "::", "PPC970_LSU", ":", "case", "PPCII", "::", "PPC970_FPU", ":", "case", "PPCII", "::", "PPC970_VALU", ":", "case", "PPCII", "::", "PPC970_VPERM", ":", "if", "(", "NumIssued", "==", "4", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_CRU", ":", "if", "(", "NumIssued", ">=", "2", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_BRU", ":", "break", ";", "}", "if", "(", "HasCTRSet", "&&", "(", "Opcode", "==", "PPC", "::", "BCTRL_Darwin", "\|\|", "Opcode", "==", "PPC", "::", "BCTRL_SVR4", ")", ")", "return", "NoopHazard", ";", "if", "(", "isLoad", "&&", "NumStores", ")", "{", "unsigned", "LoadSize", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown load!\"", ")", ";", "case", "PPC", "::", "LBZ", ":", "case", "PPC", "::", "LBZU", ":", "case", "PPC", "::", "LBZX", ":", "case", "PPC", "::", "LBZ8", ":", "case", "PPC", "::", "LBZU8", ":", "case", "PPC", "::", "LBZX8", ":", "case", "PPC", "::", "LVEBX", ":", "LoadSize", "=", "1", ";", "break", ";", "case", "PPC", "::", "LHA", ":", "case", "PPC", "::", "LHAU", ":", "case", "PPC", "::", "LHAX", ":", "case", "PPC", "::", "LHZ", ":", "case", "PPC", "::", "LHZU", ":", "case", "PPC", "::", "LHZX", ":", "case", "PPC", "::", "LVEHX", ":", "case", "PPC", "::", "LHBRX", ":", "case", "PPC", "::", "LHA8", ":", "case", "PPC", "::", "LHAU8", ":", "case", "PPC", "::", "LHAX8", ":", "case", "PPC", "::", "LHZ8", ":", "case", "PPC", "::", "LHZU8", ":", "case", "PPC", "::", "LHZX8", ":", "LoadSize", "=", "2", ";", "break", ";", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFSU", ":", "case", "PPC", "::", "LFSX", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LWZU", ":", "case", "PPC", "::", "LWZX", ":", "case", "PPC", "::", "LWA", ":", "case", "PPC", "::", "LWAX", ":", "case", "PPC", "::", "LVEWX", ":", "case", "PPC", "::", "LWBRX", ":", "case", "PPC", "::", "LWZ8", ":", "case", "PPC", "::", "LWZX8", ":", "LoadSize", "=", "4", ";", "break", ";", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "LFDU", ":", "case", "PPC", "::", "LFDX", ":", "case", "PPC", "::", "LD", ":", "case", "PPC", "::", "LDU", ":", "case", "PPC", "::", "LDX", ":", "LoadSize", "=", "8", ";", "break", ";", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "LVXL", ":", "LoadSize", "=", "16", ";", "break", ";", "}", "if", "(", "isLoadOfStoredAddress", "(", "LoadSize", ",", "Node", "->", "getOperand", "(", "0", ")", ",", "Node", "->", "getOperand", "(", "1", ")", ")", ")", "return", "NoopHazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]	[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]	[ "PowerPC", "PPC", "0", "\"PPC hazards don't support scoreboard lookahead\"", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "0", "2", "\"Unknown instruction type!\"", "PPCII::PPC970_FXU", "PPCII::PPC970_LSU", "PPCII::PPC970_FPU", "PPCII::PPC970_VALU", "PPCII::PPC970_VPERM", "4", "PPCII::PPC970_CRU", "2", "PPCII::PPC970_BRU", "PPC::BCTRL_Darwin", "PPC::BCTRL_SVR4", "\"Unknown load!\"", "PPC::LBZ", "PPC::LBZU", "PPC::LBZX", "PPC::LBZ8", "PPC::LBZU8", "PPC::LBZX8", "PPC::LVEBX", "1", "PPC::LHA", "PPC::LHAU", "PPC::LHAX", "PPC::LHZ", "PPC::LHZU", "PPC::LHZX", "PPC::LVEHX", "PPC::LHBRX", "PPC::LHA8", "PPC::LHAU8", "PPC::LHAX8", "PPC::LHZ8", "PPC::LHZU8", "PPC::LHZX8", "2", "PPC::LFS", "PPC::LFSU", "PPC::LFSX", "PPC::LWZ", "PPC::LWZU", "PPC::LWZX", "PPC::LWA", "PPC::LWAX", "PPC::LVEWX", "PPC::LWBRX", "PPC::LWZ8", "PPC::LWZX8", "4", "PPC::LFD", "PPC::LFDU", "PPC::LFDX", "PPC::LD", "PPC::LDU", "PPC::LDX", "8", "PPC::LVX", "PPC::LVXL", "16", "0", "1" ]	PPCHazardRecognizers30	getHazardType	PowerPC	CPU	LLVM	16,574	500	1	[]
[ "<s>", "void", "SystemZFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "SystemZMachineFunctionInfo", "", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", ";", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "MFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "NumArgGPRs", ";", "++", "I", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "ArgGPRs", "[", "I", "]", ")", ";", "if", "(", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R6D", ")", ";", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R7D", ")", ";", "}", "if", "(", "HasFP", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "if", "(", "MFFrame", ".", "hasCalls", "(", ")", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R14D", ")", ";", "const", "MCPhysReg", "", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "CSRegs", "[", "I", "]", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSRegs", "[", "I", "]", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", "&&", "SavedRegs", ".", "test", "(", "Reg", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "break", ";", "}", "}", "}", "</s>" ]	[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]	[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R11D", "SystemZ::R14D", "0", "SystemZ::GR64BitRegClass", "SystemZ::R15D" ]	SystemZFrameLowering1	determineCalleeSaves	SystemZ	CPU	LLVM	16,575	258	1	[]
[ "<s>", "void", "X86ATTInstPrinter", "::", "printInst", "(", "const", "MCInst", "", "MI", ",", "raw_ostream", "&", "OS", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "", "CommentStream", ",", "getRegisterName", ")", ";", "}", "</s>" ]	[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]	[ "X86", "X86", "X86" ]	X86ATTInstPrinter12	printInst	X86	CPU	LLVM	16,576	37	1	[]
[ "<s>", "int", "c4x_R_constraint", "(", "rtx", "op", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "TARGET_C3X", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", ")", "return", "0", ";", "if", "(", "mode", "==", "HImode", "\|\|", "mode", "==", "HFmode", ")", "return", "IS_UINT5_CONST", "(", "INTVAL", "(", "op1", ")", "+", "1", ")", ";", "return", "IS_UINT5_CONST", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]	[ "ARx", "+", "5-bit", "unsigned", "const", "", "ARx", ",", "", "+ARx", "(", "n", ")", "for", "n", "<", "32", "." ]	[ "c4x", "0", "0", "0", "1", "0", "1", "0", "0", "1", "0" ]	c4x1	c4x_R_constraint	c4x	DSP	GCC	16,577	147	1	[]
[ "<s>", "Register", "LC2200RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "LC2200Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "LC2200Subtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "LC2200", "::", "fp", ":", "LC2200", "::", "sp", ";", "}", "</s>" ]	[ "Debug", "information", "queries", "." ]	[ "LC2200", "LC2200", "LC2200", "LC2200", "LC2200::fp", "LC2200::sp" ]	LC2200RegisterInfo	getFrameRegister	LC2200	CPU	LLVM	16,578	54	1	[]
[ "<s>", "int", "ARMBaseInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "", "ItinData", ",", "const", "MachineInstr", "", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "if", "(", "!", "ItinData", "\|\|", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "-", "1", ";", "const", "MachineOperand", "&", "DefMO", "=", "DefMI", "->", "getOperand", "(", "DefIdx", ")", ";", "unsigned", "Reg", "=", "DefMO", ".", "getReg", "(", ")", ";", "const", "MCInstrDesc", "", "DefMCID", "=", "&", "DefMI", "->", "getDesc", "(", ")", ";", "const", "MCInstrDesc", "", "UseMCID", "=", "&", "UseMI", "->", "getDesc", "(", ")", ";", "unsigned", "DefAdj", "=", "0", ";", "if", "(", "DefMI", "->", "isBundle", "(", ")", ")", "{", "DefMI", "=", "getBundledDefMI", "(", "&", "getRegisterInfo", "(", ")", ",", "DefMI", ",", "Reg", ",", "DefIdx", ",", "DefAdj", ")", ";", "DefMCID", "=", "&", "DefMI", "->", "getDesc", "(", ")", ";", "}", "if", "(", "DefMI", "->", "isCopyLike", "(", ")", "\|\|", "DefMI", "->", "isInsertSubreg", "(", ")", "\|\|", "DefMI", "->", "isRegSequence", "(", ")", "\|\|", "DefMI", "->", "isImplicitDef", "(", ")", ")", "{", "return", "1", ";", "}", "unsigned", "UseAdj", "=", "0", ";", "if", "(", "UseMI", "->", "isBundle", "(", ")", ")", "{", "unsigned", "NewUseIdx", ";", "const", "MachineInstr", "", "NewUseMI", "=", "getBundledUseMI", "(", "&", "getRegisterInfo", "(", ")", ",", "UseMI", ",", "Reg", ",", "NewUseIdx", ",", "UseAdj", ")", ";", "if", "(", "!", "NewUseMI", ")", "return", "-", "1", ";", "UseMI", "=", "NewUseMI", ";", "UseIdx", "=", "NewUseIdx", ";", "UseMCID", "=", "&", "UseMI", "->", "getDesc", "(", ")", ";", "}", "if", "(", "Reg", "==", "ARM", "::", "CPSR", ")", "{", "if", "(", "DefMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "FMSTAT", ")", "{", "return", "Subtarget", ".", "isLikeA9", "(", ")", "?", "1", ":", "20", ";", "}", "if", "(", "UseMI", "->", "isBranch", "(", ")", ")", "return", "0", ";", "unsigned", "Latency", "=", "getInstrLatency", "(", "ItinData", ",", "DefMI", ")", ";", "if", "(", "Latency", ">", "0", "&&", "Subtarget", ".", "isThumb2", "(", ")", ")", "{", "const", "MachineFunction", "", "MF", "=", "DefMI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getFnAttributes", "(", ")", ".", "hasAttribute", "(", "Attributes", "::", "OptimizeForSize", ")", ")", "--", "Latency", ";", "}", "return", "Latency", ";", "}", "if", "(", "DefMO", ".", "isImplicit", "(", ")", "\|\|", "UseMI", "->", "getOperand", "(", "UseIdx", ")", ".", "isImplicit", "(", ")", ")", "return", "-", "1", ";", "unsigned", "DefAlign", "=", "DefMI", "->", "hasOneMemOperand", "(", ")", "?", "(", "", "DefMI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "unsigned", "UseAlign", "=", "UseMI", "->", "hasOneMemOperand", "(", ")", "?", "(", "", "UseMI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "int", "Latency", "=", "getOperandLatency", "(", "ItinData", ",", "", "DefMCID", ",", "DefIdx", ",", "DefAlign", ",", "*", "UseMCID", ",", "UseIdx", ",", "UseAlign", ")", ";", "if", "(", "Latency", "<", "0", ")", "return", "Latency", ";", "int", "Adj", "=", "DefAdj", "+", "UseAdj", ";", "Adj", "+=", "adjustDefLatency", "(", "Subtarget", ",", "DefMI", ",", "DefMCID", ",", "DefAlign", ")", ";", "if", "(", "Adj", ">=", "0", "\|\|", "(", "int", ")", "Latency", ">", "-", "Adj", ")", "{", "return", "Latency", "+", "Adj", ";", "}", "return", "Latency", ";", "}", "</s>" ]	[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]	[ "ARM", "ARM", "1", "0", "1", "0", "1", "ARM::CPSR", "ARM::FMSTAT", "1", "20", "0", "0", "1", "0", "0", "0", "0" ]	ARMBaseInstrInfo101	getOperandLatency	ARM	CPU	LLVM	16,579	483	1	[]
[ "<s>", "BlackfinTargetLowering", "::", "ConstraintType", "BlackfinTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "!=", "1", ")", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'a'", ":", "case", "'d'", ":", "case", "'z'", ":", "case", "'D'", ":", "case", "'W'", ":", "case", "'e'", ":", "case", "'b'", ":", "case", "'v'", ":", "case", "'f'", ":", "case", "'c'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'k'", ":", "case", "'x'", ":", "case", "'y'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'A'", ":", "case", "'B'", ":", "case", "'C'", ":", "case", "'Z'", ":", "case", "'Y'", ":", "return", "C_Register", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]	[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]	[ "Blackfin", "1", "0" ]	BlackfinISelLowering	getConstraintType	Blackfin	DSP	LLVM	16,580	127	1	[]
[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]	[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]	[ "X86" ]	X86FixupBWInsts1	getAnalysisUsage	X86	CPU	LLVM	16,581	27	1	[]
[ "<s>", "static", "bool", "ix86_legitimate_constant_p", "(", "machine_mode", ",", "rtx", "x", ")", "{", "if", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "darwin_local_data_pic", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOT", ":", "case", "UNSPEC_GOTOFF", ":", "case", "UNSPEC_PLTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "case", "UNSPEC_NTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "case", "UNSPEC_DTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "SYMBOL_REF_DLLIMPORT_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "MACHO_DYNAMIC_NO_PIC_P", ")", "return", "machopic_symbol_defined_p", "(", "x", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "TImode", "&&", "x", "!=", "CONST0_RTX", "(", "TImode", ")", "&&", "!", "TARGET_64BIT", ")", "return", "false", ";", "break", ";", "case", "CONST_VECTOR", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]	[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]	[ "i386", "0", "1", "0", "1", "0", "0", "0", "0" ]	i3864	ix86_legitimate_constant_p	i386	CPU	GCC	16,582	304	1	[]
[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "\|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]	[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]	[ "AZPR" ]	DelaySlotFiller	runOnMachineFunction	AZPR	CPU	LLVM	16,583	53	1	[]
[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "Count", "%", "4", "!=", "0", ")", "return", "false", ";", "uint64_t", "NumNops", "=", "Count", "/", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "NumNops", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0x60000000", ")", ";", "return", "true", ";", "}", "</s>" ]	[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]	[ "PowerPC", "4", "0", "4", "0", "0x60000000" ]	PPCAsmBackend12	writeNopData	PowerPC	CPU	LLVM	16,584	55	1	[]
[ "<s>", "static", "uint16_t", "name", "(", "struct", "InternalInstruction", "", "insn", ",", "OperandType", "type", ",", "\\", "uint8_t", "index", ",", "uint8_t", "", "valid", ")", "{", "\\", "", "valid", "=", "1", ";", "\\", "switch", "(", "type", ")", "{", "\\", "default", ":", "\\", "debug", "(", "\"Unhandled register type\"", ")", ";", "\\", "", "valid", "=", "0", ";", "\\", "return", "0", ";", "\\", "case", "TYPE_Rv", ":", "\\", "return", "base", "+", "index", ";", "\\", "case", "TYPE_R8", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "", "valid", "=", "0", ";", "\\", "if", "(", "insn", "->", "rexPrefix", "&&", "index", ">=", "4", "&&", "index", "<=", "7", ")", "{", "\\", "return", "prefix", "##", "_SPL", "+", "(", "index", "-", "4", ")", ";", "\\", "}", "else", "{", "\\", "return", "prefix", "##", "_AL", "+", "index", ";", "\\", "}", "\\", "case", "TYPE_R16", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_AX", "+", "index", ";", "\\", "case", "TYPE_R32", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_EAX", "+", "index", ";", "\\", "case", "TYPE_R64", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_RAX", "+", "index", ";", "\\", "case", "TYPE_ZMM", ":", "\\", "return", "prefix", "##", "_ZMM0", "+", "index", ";", "\\", "case", "TYPE_YMM", ":", "\\", "return", "prefix", "##", "_YMM0", "+", "index", ";", "\\", "case", "TYPE_XMM", ":", "\\", "return", "prefix", "##", "_XMM0", "+", "index", ";", "\\", "case", "TYPE_TMM", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_TMM0", "+", "index", ";", "\\", "case", "TYPE_VK", ":", "\\", "index", "&=", "0xf", ";", "\\", "if", "(", "index", ">", "7", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_K0", "+", "index", ";", "\\", "case", "TYPE_VK_PAIR", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_K0_K1", "+", "(", "index", "/", "2", ")", ";", "\\", "case", "TYPE_MM64", ":", "\\", "return", "prefix", "##", "_MM0", "+", "(", "index", "&", "0x7", ")", ";", "\\", "case", "TYPE_SEGMENTREG", ":", "\\", "if", "(", "(", "index", "&", "7", ")", ">", "5", ")", "\\", "", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_ES", "+", "(", "index", "&", "7", ")", ";", "\\", "case", "TYPE_DEBUGREG", ":", "\\", "return", "prefix", "##", "_DR0", "+", "index", ";", "\\", "case", "TYPE_CONTROLREG", ":", "\\", "return", "prefix", "##", "_CR0", "+", "index", ";", "\\", "case", "TYPE_BNDR", ":", "\\", "if", "(", "index", ">", "3", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_BND0", "+", "index", ";", "\\", "case", "TYPE_MVSIBX", ":", "\\", "return", "prefix", "##", "_XMM0", "+", "index", ";", "\\", "case", "TYPE_MVSIBY", ":", "\\", "return", "prefix", "##", "_YMM0", "+", "index", ";", "\\", "case", "TYPE_MVSIBZ", ":", "\\", "return", "prefix", "##", "_ZMM0", "+", "index", ";", "\\", "}", "\\", "}", "</s>" ]	[ "Gets", "the", "name", "of", "the", "pass", "we", "are", "mixed", "into", "." ]	[ "X86", "1", "\"Unhandled register type\"", "0", "0", "0xf", "0", "4", "7", "4", "0xf", "0", "0xf", "0", "0xf", "0", "7", "0", "0xf", "7", "0", "7", "0", "2", "0x7", "7", "5", "0", "7", "3", "0" ]	X86Disassembler24	name	X86	CPU	LLVM	16,585	474	1	[]
[ "<s>", "static", "void", "h8300_insert_attributes", "(", "tree", "node", ",", "tree", "", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "node", ")", "==", "FUNCTION_DECL", ")", "{", "if", "(", "pragma_interrupt", ")", "{", "pragma_interrupt", "=", "0", ";", "", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"interrupt_handler\"", ")", ",", "NULL", ",", "", "attributes", ")", ";", "}", "if", "(", "pragma_saveall", ")", "{", "pragma_saveall", "=", "0", ";", "", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"saveall\"", ")", ",", "NULL", ",", "*", "attributes", ")", ";", "}", "}", "}", "</s>" ]	[ "Generate", "an", "'interrupt_handler", "'", "attribute", "for", "decls", ".", "We", "convert", "all", "the", "pragmas", "to", "corresponding", "attributes", "." ]	[ "h8300", "0", "\"interrupt_handler\"", "0", "\"saveall\"" ]	h8300	h8300_insert_attributes	h8300	MPU	GCC	16,586	76	1	[]
[ "<s>", "DecodeStatus", "SparcDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "bool", "isLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "isLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "Sparc", "::", "FeatureV9", "]", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableSparcV932", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "else", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableSparcV832", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableSparc32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]	[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]	[ "Sparc", "Sparc", "Sparc::FeatureV9", "Sparc", "Sparc", "Sparc", "4" ]	SparcDisassembler (2)1	getInstruction	Sparc	CPU	LLVM	16,587	178	1	[]
[ "<s>", "const", "TargetRegisterClass", "", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "\|\|", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "\|\|", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "\|\|", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREXRegClass", ";", "return", "&", "X86", "::", "GR32_NOREXRegClass", ";", "case", "3", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "\|\|", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREX_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOREX_NOSPRegClass", ";", "case", "4", ":", "const", "Function", "", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "\|\|", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_64_Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]	[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]	[ "X86", "X86", "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_NOREXRegClass", "X86::GR32_NOREXRegClass", "3", "X86::GR64_NOREX_NOSPRegClass", "X86::GR32_NOREX_NOSPRegClass", "4", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]	X86RegisterInfo87	getPointerRegClass	X86	CPU	LLVM	16,588	245	1	[]
[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "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", "(", "Subtarget", "->", "hasMSA", "(", ")", "&&", "type", "->", "isVectorTy", "(", ")", "&&", "cast", "<", "VectorType", ">", "(", "type", ")", "->", "getBitWidth", "(", ")", "==", "128", ")", "weight", "=", "CW_Register", ";", "else", "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", "128" ]	MipsISelLowering (2)1	getSingleConstraintMatchWeight	Mips	CPU	LLVM	16,589	214	1	[]
[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "14", ";", "}", "</s>" ]	[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]	[ "AAP", "14" ]	AAPAsmBackend	getNumFixupKinds	AAP	MPU	LLVM	16,590	11	1	[]
[ "<s>", "int", "loongarch_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "HARD_REG_SET", "left", ";", "size", "=", "0x8000", ";", "left", "=", "reg_class_contents", "[", "rclass", "]", ";", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FCC_REGS", "]", ")", ")", "{", "if", "(", "loongarch_hard_regno_mode_ok", "(", "FCC_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "4", ")", ";", "left", "&=", "~", "reg_class_contents", "[", "FCC_REGS", "]", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "loongarch_hard_regno_mode_ok", "(", "FP_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_FPREG", ")", ";", "left", "&=", "~", "reg_class_contents", "[", "FP_REGS", "]", ";", "}", "if", "(", "!", "hard_reg_set_empty_p", "(", "left", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "size", "-", "1", ")", "/", "size", ";", "}", "</s>" ]	[ "Implement", "CLASS_MAX_NREGS", ",", "taking", "the", "maximum", "of", "the", "cases", "in", "loongarch_hard_regno_nregs", "." ]	[ "loongarch", "0x8000", "4", "1" ]	loongarch	loongarch_class_max_nregs	loongarch	CPU	GCC	16,591	146	1	[]
[ "<s>", "SDValue", "ARM64SelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "ConstantSDNode", "", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "const", "char", "", "bzeroEntry", "=", "(", "V", "&&", "V", "->", "isNullValue", "(", ")", ")", "?", "Subtarget", "->", "getBZeroEntry", "(", ")", ":", "nullptr", ";", "if", "(", "bzeroEntry", "&&", "(", "!", "SizeValue", "\|\|", "SizeValue", "->", "getZExtValue", "(", ")", ">", "256", ")", ")", "{", "const", "ARM64TargetLowering", "&", "TLI", "=", "", "static_cast", "<", "const", "ARM64TargetLowering", "", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "EVT", "IntPtr", "=", "TLI", ".", "getPointerTy", "(", ")", ";", "Type", "", "IntPtrTy", "=", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "", "DAG", ".", "getContext", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "CallingConv", "::", "C", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "bzeroEntry", ",", "IntPtr", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]	[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]	[ "ARM64", "ARM64", "256", "ARM64", "ARM64", "0" ]	ARM64SelectionDAGInfo	EmitTargetCodeForMemset	ARM64	CPU	LLVM	16,592	277	1	[]
[ "<s>", "bool", "NVPTXFavorNonGenericAddrSpaces", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "DisableFavorNonGeneric", "\|\|", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "B", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "B", ")", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "Changed", "\|=", "optimizeMemoryInstruction", "(", "&", "I", ",", "0", ")", ";", "}", "else", "if", "(", "isa", "<", "StoreInst", ">", "(", "I", ")", ")", "{", "Changed", "\|=", "optimizeMemoryInstruction", "(", "&", "I", ",", "1", ")", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]	[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]	[ "NVPTX", "NVPTX", "0", "1" ]	NVPTXFavorNonGenericAddrSpaces8	runOnFunction	NVPTX	GPU	LLVM	16,593	96	1	[]
[ "<s>", "unsigned", "char", "X86Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "bool", "isDecl", "=", "GV", "->", "isDeclarationForLinker", "(", ")", ";", "if", "(", "isPICStyleRIPRel", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDefaultVisibility", "(", ")", "&&", "(", "isDecl", "\|\|", "GV", "->", "isWeakForLinker", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "else", "if", "(", "!", "isTargetWin64", "(", ")", ")", "{", "assert", "(", "isTargetELF", "(", ")", "&&", "\"Unknown rip-relative target\"", ")", ";", "if", "(", "!", "GV", "->", "hasLocalLinkage", "(", ")", "&&", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "if", "(", "isPICStyleGOT", "(", ")", ")", "{", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", "\|\|", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTOFF", ";", "return", "X86II", "::", "MO_GOT", ";", "}", "if", "(", "isPICStyleStubPIC", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "if", "(", "isDecl", "\|\|", "GV", "->", "hasCommonLinkage", "(", ")", ")", "{", "return", "X86II", "::", "MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "if", "(", "isPICStyleStubNoDynamic", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]	[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]	[ "X86", "X86", "X86II::MO_DLLIMPORT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "\"Unknown rip-relative target\"", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "X86II::MO_GOT", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]	X86Subtarget (2)1	ClassifyGlobalReference	X86	CPU	LLVM	16,594	283	1	[]
[ "<s>", "void", "SystemZPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZShortenInstPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZElimComparePass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createSystemZLongBranchPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "PostMachineSchedulerID", ")", ";", "}", "</s>" ]	[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]	[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]	SystemZTargetMachine18	addPreEmitPass	SystemZ	CPU	LLVM	16,595	74	1	[]
[ "<s>", "MachineInstr", "", "LanaiInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "", ">", "&", "SeenMIs", ",", "bool", ")", "const", "{", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "SELECT", "&&", "\"unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "1", ":", "2", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "add", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "getOppositeCondition", "(", "LPCC", "::", "CondCode", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "copyImplicitOps", "(", "MI", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "add", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]	[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]	[ "Lanai", "Lanai", "Lanai::SELECT", "\"unknown select instruction\"", "1", "2", "1", "2", "0", "1", "3", "0", "1" ]	LanaiInstrInfo (2)	optimizeSelect	Lanai	CPU	LLVM	16,596	377	1	[]
[ "<s>", "static", "bool", "mips_cfg_in_reorg", "(", "void", ")", "{", "return", "(", "mips_r10k_cache_barrier", "!=", "R10K_CACHE_BARRIER_NONE", "\|\|", "TARGET_RELAX_PIC_CALLS", ")", ";", "}", "</s>" ]	[ "Return", "whether", "CFG", "is", "used", "in", "mips_reorg", "." ]	[ "mips" ]	mips	mips_cfg_in_reorg	mips	CPU	GCC	16,597	17	1	[]
[ "<s>", "bool", "WebAssemblyOptimizeLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"******** Optimize LiveIntervals ******\\n\"", "\"******** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "LiveIntervals", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"OptimizeLiveIntervals expects liveness\"", ")", ";", "SmallVector", "<", "LiveInterval", "", ",", "4", ">", "SplitLIs", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "LIS", ".", "splitSeparateComponents", "(", "LIS", ".", "getInterval", "(", "Reg", ")", ",", "SplitLIs", ")", ";", "SplitLIs", ".", "clear", "(", ")", ";", "}", "for", "(", "auto", "MII", "=", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "MIE", "=", "MF", ".", "begin", "(", ")", "->", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "", "MI", "=", "&", "", "MII", "++", ";", "if", "(", "MI", "->", "isImplicitDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "LIS", ".", "removeVRegDefAt", "(", "LI", ",", "LIS", ".", "getInstructionIndex", "(", "", "MI", ")", ".", "getRegSlot", "(", ")", ")", ";", "LIS", ".", "RemoveMachineInstrFromMaps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]	[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]	[ "WebAssembly", "WebAssembly", "\"******** Optimize LiveIntervals ******\\n\"", "\"******** Function: \"", "\"OptimizeLiveIntervals expects liveness\"", "4", "0", "0", "0" ]	WebAssemblyOptimizeLiveIntervals14	runOnMachineFunction	WebAssembly	Virtual ISA	LLVM	16,598	261	1	[]
[ "<s>", "static", "bool", "aarch64_validate_mcpu", "(", "const", "char", "", "str", ",", "const", "struct", "processor", "", "", "res", ",", "unsigned", "long", "", "isa_flags", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_cpu", "(", "str", ",", "res", ",", "isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "return", "true", ";", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing cpu name in %<-mcpu=%s%>\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"unknown value %qs for -mcpu\"", ",", "str", ")", ";", "aarch64_print_hint_for_core", "(", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid feature modifier in %<-mcpu=%s%>\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]	[ "Validate", "a", "command-line", "-mcpu", "option", ".", "Parse", "the", "cpu", "and", "extensions", "(", "if", "any", ")", "specified", "in", "STR", "and", "throw", "errors", "if", "appropriate", ".", "Put", "the", "results", "if", "they", "are", "valid", "in", "RES", "and", "ISA_FLAGS", ".", "Return", "whether", "the", "option", "is", "valid", "." ]	[ "aarch64", "\"missing cpu name in %<-mcpu=%s%>\"", "\"unknown value %qs for -mcpu\"", "\"invalid feature modifier in %<-mcpu=%s%>\"" ]	aarch644	aarch64_validate_mcpu	aarch64	CPU	GCC	16,599	101	1	[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "AMDGPUSubtarget", "::", "getWavesPerEU", "(", "const", "Function", "&", "F", ")", "const", "{", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Default", "(", "1", ",", "getMaxWavesPerEU", "(", ")", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "FlatWorkGroupSizes", "=", "getFlatWorkGroupSizes", "(", "F", ")", ";", "unsigned", "MinImpliedByFlatWorkGroupSize", "=", "getMaxWavesPerEU", "(", "FlatWorkGroupSizes", ".", "second", ")", ";", "bool", "RequestedFlatWorkGroupSize", "=", "false", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-max-work-group-size\"", ")", "||", "F", ".", "hasFnAttribute", "(", "\"amdgpu-flat-work-group-size\"", ")", ")", "{", "Default", ".", "first", "=", "MinImpliedByFlatWorkGroupSize", ";", "RequestedFlatWorkGroupSize", "=", "true", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "Requested", "=", "AMDGPU", "::", "getIntegerPairAttribute", "(", "F", ",", "\"amdgpu-waves-per-eu\"", ",", "Default", ",", "true", ")", ";", "if", "(", "Requested", ".", "second", "&&", "Requested", ".", "first", ">", "Requested", ".", "second", ")", "return", "Default", ";", "if", "(", "Requested", ".", "first", "<", "getMinWavesPerEU", "(", ")", "||", "Requested", ".", "first", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "Requested", ".", "second", ">", "getMaxWavesPerEU", "(", ")", ")", "return", "Default", ";", "if", "(", "RequestedFlatWorkGroupSize", "&&", "Requested", ".", "first", ">", "MinImpliedByFlatWorkGroupSize", ")", "return", "Default", ";", "return", "Requested", ";", "}", "</s>" ]

[ "Overload", "which", "uses", "the", "specified", "values", "for", "the", "flat", "work", "group", "sizes", ",", "rather", "than", "querying", "the", "function", "itself", "." ]

[ "AMDGPU", "AMDGPU", "1", "\"amdgpu-max-work-group-size\"", "\"amdgpu-flat-work-group-size\"", "AMDGPU::getIntegerPairAttribute", "\"amdgpu-waves-per-eu\"" ]

AMDGPUSubtarget10

getWavesPerEU

AMDGPU

GPU

LLVM

16,500

185

1

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "canCombineStoreAndExtract", "(", "Type", "*", "VectorTy", ",", "Value", "*", "Idx", ",", "unsigned", "&", "Cost", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "false", ";", "if", "(", "VectorTy", "->", "isFPOrFPVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isa", "<", "ConstantInt", ">", "(", "Idx", ")", ")", "return", "false", ";", "assert", "(", "VectorTy", "->", "isVectorTy", "(", ")", "&&", "\"VectorTy is not a vector type\"", ")", ";", "unsigned", "BitWidth", "=", "VectorTy", "->", "getPrimitiveSizeInBits", "(", ")", ".", "getFixedSize", "(", ")", ";", "if", "(", "BitWidth", "==", "64", "||", "BitWidth", "==", "128", ")", "{", "Cost", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "can", "combine", "store", "(", "extractelement", "VectorTy", ",", "Idx", ")", "." ]

[ "ARM", "ARM", "\"VectorTy is not a vector type\"", "64", "128", "0" ]

ARMISelLowering (2)5

canCombineStoreAndExtract

ARM

CPU

LLVM

16,501

103

1

[]

[ "<s>", "int", "ix86_data_alignment", "(", "tree", "type", ",", "int", "align", ",", "bool", "opt", ")", "{", "int", "max_align_compat", "=", "MIN", "(", "256", ",", "MAX_OFILE_ALIGNMENT", ")", ";", "int", "max_align", "=", "MIN", "(", "(", "unsigned", ")", "ix86_tune_cost", "->", "prefetch_block", "*", "8", ",", "MAX_OFILE_ALIGNMENT", ")", ";", "if", "(", "max_align", "<", "BITS_PER_WORD", ")", "max_align", "=", "BITS_PER_WORD", ";", "switch", "(", "ix86_align_data_type", ")", "{", "case", "ix86_align_data_type_abi", ":", "opt", "=", "false", ";", "break", ";", "case", "ix86_align_data_type_compat", ":", "max_align", "=", "BITS_PER_WORD", ";", "break", ";", "case", "ix86_align_data_type_cacheline", ":", "break", ";", "}", "if", "(", "TARGET_IAMCU", ")", "align", "=", "iamcu_alignment", "(", "type", ",", "align", ")", ";", "if", "(", "opt", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", ")", "{", "if", "(", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "max_align_compat", ")", "&&", "align", "<", "max_align_compat", ")", "align", "=", "max_align_compat", ";", "if", "(", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "max_align", ")", "&&", "align", "<", "max_align", ")", "align", "=", "max_align", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "(", "opt", "?", "AGGREGATE_TYPE_P", "(", "type", ")", ":", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "wi", "::", "geu_p", "(", "TYPE_SIZE", "(", "type", ")", ",", "128", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "if", "(", "!", "opt", ")", "return", "align", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DCmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "(", "TYPE_MODE", "(", "type", ")", "==", "XCmode", "||", "TYPE_MODE", "(", "type", ")", "==", "TCmode", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "QUAL_UNION_TYPE", ")", "&&", "TYPE_FIELDS", "(", "type", ")", ")", "{", "if", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "DECL_MODE", "(", "TYPE_FIELDS", "(", "type", ")", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "REAL_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "&&", "align", "<", "64", ")", "return", "64", ";", "if", "(", "ALIGN_MODE_128", "(", "TYPE_MODE", "(", "type", ")", ")", "&&", "align", "<", "128", ")", "return", "128", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Compute", "the", "alignment", "for", "a", "static", "variable", ".", "TYPE", "is", "the", "data", "type", ",", "and", "ALIGN", "is", "the", "alignment", "that", "the", "object", "would", "ordinarily", "have", ".", "The", "value", "of", "this", "function", "is", "used", "instead", "of", "that", "alignment", "to", "align", "the", "object", "." ]

[ "i386", "256", "8", "128", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128", "64", "64", "128", "128" ]

i3865

ix86_data_alignment

i386

CPU

GCC

16,502

466

1

[]

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

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

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

ARMTargetTransformInfo (2)1

getNumberOfRegisters

ARM

CPU

LLVM

16,503

63

1

[]

[ "<s>", "static", "void", "nios2_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", ",", "int", "second_time", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "cumulative_args_t", "local_cum_v", "=", "pack_cumulative_args", "(", "&", "local_cum", ")", ";", "int", "regs_to_push", ";", "int", "pret_size", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "local_cum", "=", "*", "cum", ";", "nios2_function_arg_advance", "(", "local_cum_v", ",", "mode", ",", "type", ",", "true", ")", ";", "regs_to_push", "=", "NUM_ARG_REGS", "-", "local_cum", ".", "regs_used", ";", "if", "(", "!", "TARGET_HAS_CDX", "&&", "!", "second_time", "&&", "regs_to_push", ">", "0", ")", "{", "rtx", "ptr", "=", "virtual_incoming_args_rtx", ";", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "regs_used", "+", "FIRST_ARG_REGNO", ",", "mem", ",", "regs_to_push", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "pret_size", "=", "regs_to_push", "*", "UNITS_PER_WORD", ";", "if", "(", "pret_size", ")", "*", "pretend_size", "=", "pret_size", ";", "}", "</s>" ]

[ "TODO", ":", "It", "may", "be", "possible", "to", "eliminate", "the", "copyback", "and", "implement", "own", "va_arg", "type", "." ]

[ "nios2", "1", "0" ]

nios23

nios2_setup_incoming_varargs

nios2

MPU

GCC

16,504

152

1

[]

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

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

[ "Teak", "Teak", "Teak" ]

TeakTargetMachine

createPassConfig

Teak

DSP

LLVM

16,505

22

1

[]

[ "<s>", "static", "void", "AnalyzeArguments", "(", "CCState", "&", "State", ",", "SmallVectorImpl", "<", "CCValAssign", ">", "&", "ArgLocs", ",", "const", "SmallVectorImpl", "<", "ArgT", ">", "&", "Args", ")", "{", "static", "const", "MCPhysReg", "RegList", "[", "]", "=", "{", "CJG", "::", "R24", ",", "CJG", "::", "R25", ",", "CJG", "::", "R26", ",", "CJG", "::", "R27", ",", "CJG", "::", "R28", ",", "CJG", "::", "R29", ",", "CJG", "::", "R30", ",", "CJG", "::", "R31", "}", ";", "static", "const", "unsigned", "NbRegs", "=", "array_lengthof", "(", "RegList", ")", ";", "if", "(", "State", ".", "isVarArg", "(", ")", ")", "{", "llvm_unreachable", "(", "\"Cannot support var args\"", ")", ";", "}", "SmallVector", "<", "unsigned", ",", "4", ">", "ArgsParts", ";", "ParseFunctionArgs", "(", "Args", ",", "ArgsParts", ")", ";", "unsigned", "RegsLeft", "=", "NbRegs", ";", "bool", "UseStack", "=", "false", ";", "unsigned", "ValNo", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgsParts", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "MVT", "ArgVT", "=", "Args", "[", "ValNo", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Args", "[", "ValNo", "]", ".", "Flags", ";", "MVT", "LocVT", "=", "ArgVT", ";", "CCValAssign", "::", "LocInfo", "LocInfo", "=", "CCValAssign", "::", "Full", ";", "if", "(", "ArgFlags", ".", "isByVal", "(", ")", ")", "{", "State", ".", "HandleByVal", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "4", ",", "4", ",", "ArgFlags", ")", ";", "continue", ";", "}", "unsigned", "Parts", "=", "ArgsParts", "[", "i", "]", ";", "if", "(", "!", "UseStack", "&&", "Parts", "<=", "RegsLeft", ")", "{", "unsigned", "FirstVal", "=", "ValNo", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "{", "unsigned", "Reg", "=", "State", ".", "AllocateReg", "(", "RegList", ")", ";", "State", ".", "addLoc", "(", "CCValAssign", "::", "getReg", "(", "ValNo", "++", ",", "ArgVT", ",", "Reg", ",", "LocVT", ",", "LocInfo", ")", ")", ";", "RegsLeft", "--", ";", "}", "SmallVectorImpl", "<", "CCValAssign", ">", "::", "iterator", "B", "=", "ArgLocs", ".", "begin", "(", ")", "+", "FirstVal", ";", "std", "::", "reverse", "(", "B", ",", "B", "+", "Parts", ")", ";", "}", "else", "{", "UseStack", "=", "true", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "Parts", ";", "j", "++", ")", "CC_CJG", "(", "ValNo", "++", ",", "ArgVT", ",", "LocVT", ",", "LocInfo", ",", "ArgFlags", ",", "State", ")", ";", "}", "}", "}", "</s>" ]

[ "The", "function", "will", "invoke", "AnalyzeCallOperands", "." ]

[ "CJG", "CJG::R24", "CJG::R25", "CJG::R26", "CJG::R27", "CJG::R28", "CJG::R29", "CJG::R30", "CJG::R31", "\"Cannot support var args\"", "4", "0", "0", "ISD::ArgFlagsTy", "4", "4", "0", "0", "CJG" ]

CJGISelLowering

AnalyzeArguments

CJG

CPU

LLVM

16,506

351

1

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "&", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "auto", "&", "RI", "=", "getRegisterInfo", "(", ")", ";", "MachineOperand", "DefMO", "=", "DefMI", ".", "getOperand", "(", "DefIdx", ")", ";", "if", "(", "RI", ".", "isPhysicalRegister", "(", "DefMO", ".", "getReg", "(", ")", ")", ")", "{", "if", "(", "DefMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "DefMO", ".", "getReg", "(", ")", ",", "&", "RI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "DefMI", ".", "findRegisterDefOperandIdx", "(", "*", "SR", ",", "false", ",", "false", ",", "&", "RI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "DefIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "MachineOperand", "UseMO", "=", "UseMI", ".", "getOperand", "(", "UseIdx", ")", ";", "if", "(", "UseMO", ".", "isImplicit", "(", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SR", "(", "UseMO", ".", "getReg", "(", ")", ",", "&", "RI", ")", ";", "SR", ".", "isValid", "(", ")", ";", "++", "SR", ")", "{", "int", "Idx", "=", "UseMI", ".", "findRegisterUseOperandIdx", "(", "*", "SR", ",", "false", ",", "&", "RI", ")", ";", "if", "(", "Idx", "!=", "-", "1", ")", "{", "UseIdx", "=", "Idx", ";", "break", ";", "}", "}", "}", "}", "return", "TargetInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

[ "Hexagon", "Hexagon", "1", "1" ]

HexagonInstrInfo10

getOperandLatency

Hexagon

DSP

LLVM

16,507

224

1

[]

[ "<s>", "HexagonSubtarget", "&", "HexagonSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "static", "std", "::", "map", "<", "StringRef", ",", "HexagonArchEnum", ">", "CpuTable", "{", "{", "\"hexagonv4\"", ",", "V4", "}", ",", "{", "\"hexagonv5\"", ",", "V5", "}", ",", "{", "\"hexagonv55\"", ",", "V55", "}", ",", "{", "\"hexagonv60\"", ",", "V60", "}", ",", "{", "\"hexagonv62\"", ",", "V62", "}", ",", "}", ";", "auto", "FoundIt", "=", "CpuTable", ".", "find", "(", "CPUString", ")", ";", "if", "(", "FoundIt", "!=", "CpuTable", ".", "end", "(", ")", ")", "HexagonArchVersion", "=", "FoundIt", "->", "second", ";", "else", "llvm_unreachable", "(", "\"Unrecognized Hexagon processor version\"", ")", ";", "UseHVXOps", "=", "false", ";", "UseHVXDblOps", "=", "false", ";", "UseLongCalls", "=", "false", ";", "UseMemOps", "=", "DisableMemOps", "?", "false", ":", "EnableMemOps", ";", "ModeIEEERndNear", "=", "EnableIEEERndNear", ";", "UseBSBScheduling", "=", "hasV60TOps", "(", ")", "&&", "EnableBSBSched", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "if", "(", "EnableHexagonHVX", ".", "getPosition", "(", ")", ")", "UseHVXOps", "=", "EnableHexagonHVX", ";", "if", "(", "EnableHexagonHVXDouble", ".", "getPosition", "(", ")", ")", "UseHVXDblOps", "=", "EnableHexagonHVXDouble", ";", "if", "(", "OverrideLongCalls", ".", "getPosition", "(", ")", ")", "UseLongCalls", "=", "OverrideLongCalls", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"hexagonv4\"", "\"hexagonv5\"", "\"hexagonv55\"", "\"hexagonv60\"", "\"hexagonv62\"", "Hexagon", "\"Unrecognized Hexagon processor version\"", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

HexagonSubtarget12

initializeSubtargetDependencies

Hexagon

DSP

LLVM

16,508

168

1

[]

[ "<s>", "static", "void", "or1k_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "reload_completed", "=", "1", ";", "epilogue_completed", "=", "1", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "4", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "3", ")", ";", "if", "(", "delta", ")", "{", "rtx", "delta_rtx", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "satisfies_constraint_I", "(", "delta_rtx", ")", ")", "{", "rtx", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "PE_TMP_REGNUM", ")", ";", "emit_move_insn", "(", "scratch", ",", "delta_rtx", ")", ";", "delta_rtx", "=", "scratch", ";", "}", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "delta_rtx", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "scratch", "=", "gen_rtx_REG", "(", "Pmode", ",", "PE_TMP_REGNUM", ")", ";", "HOST_WIDE_INT", "lo", "=", "sext_hwi", "(", "vcall_offset", ",", "16", ")", ";", "HOST_WIDE_INT", "hi", "=", "vcall_offset", "-", "lo", ";", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ";", "emit_move_insn", "(", "scratch", ",", "tmp", ")", ";", "if", "(", "hi", "!=", "0", ")", "{", "rtx", "scratch2", "=", "gen_rtx_REG", "(", "Pmode", ",", "RV_REGNUM", ")", ";", "emit_move_insn", "(", "scratch2", ",", "GEN_INT", "(", "hi", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "scratch", ",", "scratch2", ")", ")", ";", "}", "tmp", "=", "plus_constant", "(", "Pmode", ",", "scratch", ",", "lo", ")", ";", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ";", "emit_move_insn", "(", "scratch", ",", "tmp", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "this_rtx", ",", "scratch", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "gcc_assert", "(", "SYMBOL_REF_LOCAL_P", "(", "funexp", ")", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "emit_barrier", "(", ")", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "reload_completed", "=", "0", ";", "epilogue_completed", "=", "0", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_ASM_OUTPUT_MI_THUNK", ".", "Output", "the", "assembler", "code", "for", "a", "thunk", "function", ".", "THUNK_DECL", "is", "the", "declaration", "for", "the", "thunk", "function", "itself", ",", "FUNCTION", "is", "the", "decl", "for", "the", "target", "function", ".", "DELTA", "is", "an", "immediate", "constant", "offset", "to", "be", "added", "to", "THIS", ".", "If", "VCALL_OFFSET", "is", "nonzero", ",", "the", "word", "at", "address", "(", "*", "THIS", "+", "VCALL_OFFSET", ")", "should", "be", "additionally", "added", "to", "THIS", "." ]

[ "or1k", "1", "1", "4", "3", "16", "0", "1", "0", "1", "1", "1", "0", "0" ]

or1k

or1k_output_mi_thunk

or1k

CPU

GCC

16,509

402

1

[]

[ "<s>", "static", "bool", "spu_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SImode", ":", "case", "E_V2DImode", ":", "case", "E_V4SFmode", ":", "case", "E_V2DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Similarly", "for", "vector", "modes", ".", "``", "Supported", "''", "here", "is", "less", "strict", ".", "At", "least", "some", "operations", "are", "supported", ";", "need", "to", "check", "optabs", "or", "builtins", "for", "further", "details", "." ]

[ "spu" ]

spu3

spu_vector_mode_supported_p

spu

MPU

GCC

16,510

41

1

[]

[ "<s>", "static", "bool", "mn10300_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode2", ")", "!=", "MODE_FLOAT", ")", "return", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode1", ")", "!=", "MODE_FLOAT", ")", "return", "false", ";", "if", "(", "TARGET_AM33", "||", "mode1", "==", "mode2", "||", "(", "GET_MODE_SIZE", "(", "mode1", ")", "<=", "4", "&&", "GET_MODE_SIZE", "(", "mode2", ")", "<=", "4", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "mn10300", "4", "4" ]

mn10300

mn10300_modes_tieable_p

mn10300

MPU

GCC

16,511

80

1

[]

[ "<s>", "bool", "SystemZTTIImpl", "::", "isLSRCostLess", "(", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C1", ",", "const", "TargetTransformInfo", "::", "LSRCost", "&", "C2", ")", "{", "return", "std", "::", "tie", "(", "C1", ".", "Insns", ",", "C1", ".", "NumRegs", ",", "C1", ".", "AddRecCost", ",", "C1", ".", "NumIVMuls", ",", "C1", ".", "NumBaseAdds", ",", "C1", ".", "ScaleCost", ",", "C1", ".", "SetupCost", ")", "<", "std", "::", "tie", "(", "C2", ".", "Insns", ",", "C2", ".", "NumRegs", ",", "C2", ".", "AddRecCost", ",", "C2", ".", "NumIVMuls", ",", "C2", ".", "NumBaseAdds", ",", "C2", ".", "ScaleCost", ",", "C2", ".", "SetupCost", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "LSR", "cost", "of", "C1", "is", "lower", "than", "C2", "." ]

[ "SystemZ", "SystemZ" ]

SystemZTargetTransformInfo23

isLSRCostLess

SystemZ

CPU

LLVM

16,512

88

1

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "enableAggressiveFMAFusion", "(", "EVT", "VT", ")", "const", "{", "assert", "(", "VT", ".", "isFloatingPoint", "(", ")", "&&", "\"Non-floating-point FMA?\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "always", "benefits", "from", "combining", "into", "FMA", "for", "a", "given", "value", "type", "." ]

[ "PowerPC", "PPC", "\"Non-floating-point FMA?\"" ]

PPCISelLowering (2)2

enableAggressiveFMAFusion

PowerPC

CPU

LLVM

16,513

25

1

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "if", "(", "AI", "->", "isFloatingPointOperation", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Size", ">", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "AI", "->", "getOperation", "(", ")", "==", "AtomicRMWInst", "::", "Nand", ")", "return", "AtomicExpansionKind", "::", "LLSC", ";", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", "&&", "Size", "<", "128", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "Subtarget", "->", "outlineAtomics", "(", ")", "&&", "Size", "<", "128", ")", "{", "if", "(", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Min", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "Max", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMin", "&&", "AI", "->", "getOperation", "(", ")", "!=", "AtomicRMWInst", "::", "UMax", ")", "{", "return", "AtomicExpansionKind", "::", "None", ";", "}", "}", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

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

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

AArch64ISelLowering10

shouldExpandAtomicRMWInIR

AArch64

CPU

LLVM

16,514

153

1

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "RISCV", "RISCV" ]

RISCVAsmParser (2)1

ParseDirective

RISCV

CPU

LLVM

16,515

13

1

[]

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

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

[ "ARM64", "ARM64" ]

ARM64RegisterInfo

requiresRegisterScavenging

ARM64

CPU

LLVM

16,516

16

1

[]

[ "<s>", "static", "const", "char", "*", "m68k_get_reloc_decoration", "(", "enum", "m68k_reloc", "reloc", ")", "{", "gcc_assert", "(", "MOTOROLA", "||", "reloc", "==", "RELOC_GOT", ")", ";", "switch", "(", "reloc", ")", "{", "case", "RELOC_GOT", ":", "if", "(", "MOTOROLA", ")", "{", "if", "(", "flag_pic", "==", "1", "&&", "TARGET_68020", ")", "return", "\"@GOT.w\"", ";", "else", "return", "\"@GOT\"", ";", "}", "else", "{", "if", "(", "TARGET_68020", ")", "{", "switch", "(", "flag_pic", ")", "{", "case", "1", ":", "return", "\":w\"", ";", "case", "2", ":", "return", "\":l\"", ";", "default", ":", "return", "\"\"", ";", "}", "}", "}", "case", "RELOC_TLSGD", ":", "return", "\"@TLSGD\"", ";", "case", "RELOC_TLSLDM", ":", "return", "\"@TLSLDM\"", ";", "case", "RELOC_TLSLDO", ":", "return", "\"@TLSLDO\"", ";", "case", "RELOC_TLSIE", ":", "return", "\"@TLSIE\"", ";", "case", "RELOC_TLSLE", ":", "return", "\"@TLSLE\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "string", "for", "TLS", "relocation", "RELOC", "." ]

[ "m68k", "1", "\"@GOT.w\"", "\"@GOT\"", "1", "\":w\"", "2", "\":l\"", "\"\"", "\"@TLSGD\"", "\"@TLSLDM\"", "\"@TLSLDO\"", "\"@TLSIE\"", "\"@TLSLE\"" ]

m68k4

m68k_get_reloc_decoration

m68k

MPU

GCC

16,517

119

1

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "MSP430::PUSH16r" ]

MSP430FrameLowering (2)

spillCalleeSavedRegisters

MSP430

MPU

LLVM

16,518

175

1

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ARMProcFamily", "(", "Others", ")", ",", "HasFPARMv8", "(", "false", ")", ",", "HasNEON", "(", "false", ")", ",", "HasCrypto", "(", "false", ")", ",", "HasCRC", "(", "false", ")", ",", "HasZeroCycleRegMove", "(", "false", ")", ",", "HasZeroCycleZeroing", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "IsLittleEndian", "(", "LittleEndian", ")", "{", "if", "(", "CPUString", ".", "empty", "(", ")", ")", "CPUString", "=", "\"generic\"", ";", "ParseSubtargetFeatures", "(", "CPUString", ",", "FS", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"generic\"" ]

AArch64Subtarget41

AArch64Subtarget

AArch64

CPU

LLVM

16,519

108

1

[]

[ "<s>", "static", "bool", "s390_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "if", "(", "TARGET_TPF_PROFILING", ")", "return", "false", ";", "if", "(", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "decl", "&&", "TREE_PUBLIC", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "TREE_OPERAND", "(", "exp", ",", "1", ")", "&&", "s390_call_saved_register_used", "(", "TREE_OPERAND", "(", "exp", ",", "1", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "given", "call", "expression", "can", "be", "turned", "into", "a", "sibling", "call", ".", "DECL", "holds", "the", "declaration", "of", "the", "function", "to", "be", "called", "whereas", "EXP", "is", "the", "call", "expression", "itself", "." ]

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

s3903

s390_function_ok_for_sibcall

s390

MPU

GCC

16,520

61

1

[]

[ "<s>", "const", "char", "*", "output_call", "(", "rtx", "*", "operands", ")", "{", "gcc_assert", "(", "!", "arm_arch5t", ")", ";", "if", "(", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "LR_REGNUM", ")", "{", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "IP_REGNUM", ")", ";", "output_asm_insn", "(", "\"mov%?\\t%0, %|lr\"", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "\"mov%?\\t%|lr, %|pc\"", ",", "operands", ")", ";", "if", "(", "TARGET_INTERWORK", "||", "arm_arch4t", ")", "output_asm_insn", "(", "\"bx%?\\t%0\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"mov%?\\t%|pc, %0\"", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "INSN", "is", "either", "a", "function", "call", "or", "a", "millicode", "call", ".", "It", "may", "have", "an", "unconditional", "jump", "in", "its", "delay", "slot", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]

[ "arm", "0", "0", "\"mov%?\\t%0, %|lr\"", "\"mov%?\\t%|lr, %|pc\"", "\"bx%?\\t%0\"", "\"mov%?\\t%|pc, %0\"", "\"\"" ]

arm

output_call

arm

CPU

GCC

16,521

81

1

[]

[ "<s>", "static", "void", "riscv_disqualify_components", "(", "sbitmap", ",", "edge", ",", "sbitmap", ",", "bool", ")", "{", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS", "." ]

[ "riscv" ]

riscv1

riscv_disqualify_components

riscv

CPU

GCC

16,522

14

1

[]

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

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

[ "AArch64", "AArch64" ]

AArch64CondBrTuning

getAnalysisUsage

AArch64

CPU

LLVM

16,523

25

1

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalInterleavedAccessType", "(", "VectorType", "*", "VecTy", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "unsigned", "VecSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", ")", ";", "unsigned", "ElSize", "=", "DL", ".", "getTypeSizeInBits", "(", "VecTy", "->", "getElementType", "(", ")", ")", ";", "if", "(", "VecTy", "->", "getElementType", "(", ")", "->", "isHalfTy", "(", ")", ")", "return", "false", ";", "if", "(", "VecTy", "->", "getNumElements", "(", ")", "<", "2", ")", "return", "false", ";", "if", "(", "ElSize", "!=", "8", "&&", "ElSize", "!=", "16", "&&", "ElSize", "!=", "32", ")", "return", "false", ";", "return", "VecSize", "==", "64", "||", "VecSize", "%", "128", "==", "0", ";", "}", "</s>" ]

[ "Returns", "whether", "or", "not", "generating", "a", "interleaved", "load/store", "intrinsic", "for", "this", "type", "will", "be", "legal", "." ]

[ "ARM", "ARM", "2", "8", "16", "32", "64", "128", "0" ]

ARMISelLowering (3)

isLegalInterleavedAccessType

ARM

CPU

LLVM

16,524

97

1

[]

[ "<s>", "void", "avr_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "operand", "ATTRIBUTE_UNUSED", ",", "int", "num_operands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "avr_log", ".", "rtx_costs", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: cost = %d. */\\n\"", ",", "set_src_cost", "(", "SET_SRC", "(", "set", ")", ",", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"/* DEBUG: pattern-cost = %d. */\\n\"", ",", "rtx_cost", "(", "PATTERN", "(", "insn", ")", ",", "VOIDmode", ",", "INSN", ",", "0", ",", "optimize_insn_for_speed_p", "(", ")", ")", ")", ";", "}", "if", "(", "avr_log", ".", "insn_addresses", ")", "fprintf", "(", "asm_out_file", ",", "\";; ADDR = %d\\n\"", ",", "(", "int", ")", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "}", "</s>" ]

[ "Output", "insn", "cost", "for", "next", "insn", "." ]

[ "avr", "\"/* DEBUG: cost = %d. */\\n\"", "\"/* DEBUG: pattern-cost = %d. */\\n\"", "0", "\";; ADDR = %d\\n\"" ]

avr

avr_final_prescan_insn

avr

MPU

GCC

16,525

115

1

[]

[ "<s>", "bool", "Z80old", "::", "splitReg", "(", "unsigned", "ByteSize", ",", "unsigned", "Opc8", ",", "unsigned", "&", "RC", ",", "unsigned", "&", "LoOpc", ",", "unsigned", "&", "LoIdx", ",", "unsigned", "&", "HiOpc", ",", "unsigned", "&", "HiIdx", ",", "unsigned", "&", "HiOff", ")", "{", "switch", "(", "ByteSize", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Size!\"", ")", ";", "case", "1", ":", "RC", "=", "Z80old", "::", "RR8RegClassID", ";", "LoOpc", "=", "HiOpc", "=", "Opc8", ";", "LoIdx", "=", "HiIdx", "=", "Z80old", "::", "NoSubRegister", ";", "HiOff", "=", "0", ";", "return", "false", ";", "case", "2", ":", "RC", "=", "Z80old", "::", "R16RegClassID", ";", "LoOpc", "=", "HiOpc", "=", "Opc8", ";", "LoIdx", "=", "Z80old", "::", "sub_low", ";", "HiIdx", "=", "Z80old", "::", "sub_high", ";", "HiOff", "=", "1", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]

[ "Z80old", "Z80old::splitReg", "\"Unexpected Size!\"", "1", "Z80old::RR8RegClassID", "Z80old::NoSubRegister", "0", "2", "Z80old::R16RegClassID", "Z80old::sub_low", "Z80old::sub_high", "1" ]

Z80oldInstrInfo

splitReg

Z80old

MPU

LLVM

16,526

114

1

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isGPRZero", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "MOVZWi", ":", "case", "AArch64", "::", "MOVZXi", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"invalid MOVZi operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "case", "AArch64", "::", "ANDWri", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", ";", "case", "AArch64", "::", "ANDXri", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "XZR", ";", "case", "TargetOpcode", "::", "COPY", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "AArch64", "::", "WZR", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "set", "its", "full", "destination", "register", "to", "zero", "?" ]

[ "AArch64", "AArch64", "AArch64::MOVZWi", "AArch64::MOVZXi", "1", "1", "0", "3", "2", "0", "\"invalid MOVZi operands\"", "AArch64::ANDWri", "1", "AArch64::WZR", "AArch64::ANDXri", "1", "AArch64::XZR", "1", "AArch64::WZR" ]

AArch64InstrInfo (2)1

isGPRZero

AArch64

CPU

LLVM

16,527

165

1

[]

[ "<s>", "bool", "NVPTXLowerAlloca", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "auto", "allocaInst", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "{", "Changed", "=", "true", ";", "auto", "ETy", "=", "allocaInst", "->", "getAllocatedType", "(", ")", ";", "auto", "LocalAddrTy", "=", "PointerType", "::", "get", "(", "ETy", ",", "ADDRESS_SPACE_LOCAL", ")", ";", "auto", "NewASCToLocal", "=", "new", "AddrSpaceCastInst", "(", "allocaInst", ",", "LocalAddrTy", ",", "\"\"", ")", ";", "auto", "GenericAddrTy", "=", "PointerType", "::", "get", "(", "ETy", ",", "ADDRESS_SPACE_GENERIC", ")", ";", "auto", "NewASCToGeneric", "=", "new", "AddrSpaceCastInst", "(", "NewASCToLocal", ",", "GenericAddrTy", ",", "\"\"", ")", ";", "NewASCToLocal", "->", "insertAfter", "(", "allocaInst", ")", ";", "NewASCToGeneric", "->", "insertAfter", "(", "NewASCToLocal", ")", ";", "for", "(", "Use", "&", "AllocaUse", ":", "llvm", "::", "make_early_inc_range", "(", "allocaInst", "->", "uses", "(", ")", ")", ")", "{", "auto", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "LI", "&&", "LI", "->", "getPointerOperand", "(", ")", "==", "allocaInst", "&&", "!", "LI", "->", "isVolatile", "(", ")", ")", "{", "LI", "->", "setOperand", "(", "LI", "->", "getPointerOperandIndex", "(", ")", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "auto", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "SI", "&&", "SI", "->", "getPointerOperand", "(", ")", "==", "allocaInst", "&&", "!", "SI", "->", "isVolatile", "(", ")", ")", "{", "SI", "->", "setOperand", "(", "SI", "->", "getPointerOperandIndex", "(", ")", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "auto", "GI", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "GI", "&&", "GI", "->", "getPointerOperand", "(", ")", "==", "allocaInst", ")", "{", "GI", "->", "setOperand", "(", "GI", "->", "getPointerOperandIndex", "(", ")", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "auto", "BI", "=", "dyn_cast", "<", "BitCastInst", ">", "(", "AllocaUse", ".", "getUser", "(", ")", ")", ";", "if", "(", "BI", "&&", "BI", "->", "getOperand", "(", "0", ")", "==", "allocaInst", ")", "{", "BI", "->", "setOperand", "(", "0", ",", "NewASCToGeneric", ")", ";", "continue", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

NVPTXLowerAlloca4

runOnFunction

NVPTX

GPU

LLVM

16,528

346

1

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "return", "getDarwinCalleeSavedRegs", "(", "MF", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Win64", ")", "return", "CSR_AArch64_AAPCS_X18_SaveList", ";", "if", "(", "hasSVEArgsOrReturn", "(", "MF", ")", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

AArch64RegisterInfo21

getCalleeSavedRegs

AArch64

CPU

LLVM

16,529

246

1

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "bool", "PendConditionalInstruction", "=", "false", ";", "SmallVector", "<", "NearMissInfo", ",", "4", ">", "NearMisses", ";", "MatchResult", "=", "MatchInstruction", "(", "Operands", ",", "Inst", ",", "NearMisses", ",", "MatchingInlineAsm", ",", "PendConditionalInstruction", ",", "Out", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Parsed as: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "forwardVPTPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Changed to: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", "&&", "!", "getTargetOptions", "(", ")", ".", "MCNoDeprecatedWarn", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "forwardVPTPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "PendConditionalInstruction", ")", "{", "PendingConditionalInsts", ".", "push_back", "(", "Inst", ")", ";", "if", "(", "isITBlockFull", "(", ")", "||", "isITBlockTerminator", "(", "Inst", ")", ")", "flushPendingInstructions", "(", "Out", ")", ";", "}", "else", "{", "Out", ".", "emitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "return", "false", ";", "case", "Match_NearMisses", ":", "ReportNearMisses", "(", "NearMisses", ",", "IDLoc", ",", "Operands", ")", ";", "return", "true", ";", "case", "Match_MnemonicFail", ":", "{", "FeatureBitset", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "ARMMnemonicSpellCheck", "(", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "\"Parsed as: \"", "\"\\n\"", "\"Changed to: \"", "\"\\n\"", "\"deprecated instruction in IT block\"", "ARM::ITasm", "ARM", "ARM", "0", "\"invalid instruction\"", "ARM", "0", "\"Implement any new match types added!\"" ]

ARMAsmParser127

MatchAndEmitInstruction

ARM

CPU

LLVM

16,530

388

1

[]

[ "<s>", "bool", "arc_store_addr_hazard_p", "(", "rtx_insn", "*", "producer", ",", "rtx_insn", "*", "consumer", ")", "{", "if", "(", "TARGET_ARC700", "&&", "(", "arc_tune", "!=", "ARC_TUNE_ARC7XX", ")", ")", "return", "true", ";", "return", "arc_store_addr_hazard_internal_p", "(", "producer", ",", "consumer", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "load", "instruction", "(", "CONSUMER", ")", "uses", "the", "same", "address", "as", "a", "store", "instruction", "(", "PRODUCER", ")", ".", "This", "function", "is", "used", "to", "avoid", "st/ld", "address", "hazard", "in", "ARC700", "cores", "." ]

[ "arc" ]

arc

arc_store_addr_hazard_p

arc

MPU

GCC

16,531

34

1

[]

[ "<s>", "static", "bool", "legitimate_small_data_address_p", "(", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "return", "legitimate_small_data_address_p", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_SMALL_P", "(", "x", ")", ";", "case", "PLUS", ":", "{", "bool", "p0", "=", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", "&&", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "bool", "p1", "=", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<=", "g_switch_value", ")", ";", "return", "p0", "&&", "p1", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "x", "is", "ok", "to", "be", "used", "as", "a", "small", "data", "address", "." ]

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

arc8

legitimate_small_data_address_p

arc

MPU

GCC

16,532

110

1

[]

[ "<s>", "bool", "scalar_chain", "::", "build", "(", "bitmap", "candidates", ",", "unsigned", "insn_uid", ",", "bitmap", "disallowed", ")", "{", "queue", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "bitmap_set_bit", "(", "queue", ",", "insn_uid", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Building chain #%d...\\n\"", ",", "chain_id", ")", ";", "while", "(", "!", "bitmap_empty_p", "(", "queue", ")", ")", "{", "insn_uid", "=", "bitmap_first_set_bit", "(", "queue", ")", ";", "bitmap_clear_bit", "(", "queue", ",", "insn_uid", ")", ";", "bitmap_clear_bit", "(", "candidates", ",", "insn_uid", ")", ";", "if", "(", "!", "add_insn", "(", "candidates", ",", "insn_uid", ",", "disallowed", ")", ")", "{", "bitmap_ior_into", "(", "disallowed", ",", "insns", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"Aborted chain #%d discovery\\n\"", ",", "chain_id", ")", ";", "BITMAP_FREE", "(", "queue", ")", ";", "return", "false", ";", "}", "}", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"Collected chain #%d...\\n\"", ",", "chain_id", ")", ";", "fprintf", "(", "dump_file", ",", "\" insns: \"", ")", ";", "dump_bitmap", "(", "dump_file", ",", "insns", ")", ";", "if", "(", "!", "bitmap_empty_p", "(", "defs_conv", ")", ")", "{", "bitmap_iterator", "bi", ";", "unsigned", "id", ";", "const", "char", "*", "comma", "=", "\"\"", ";", "fprintf", "(", "dump_file", ",", "\" defs to convert: \"", ")", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "defs_conv", ",", "0", ",", "id", ",", "bi", ")", "{", "fprintf", "(", "dump_file", ",", "\"%sr%d\"", ",", "comma", ",", "id", ")", ";", "comma", "=", "\", \"", ";", "}", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "}", "BITMAP_FREE", "(", "queue", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Build", "new", "chain", "starting", "from", "insn", "INSN_UID", "recursively", "adding", "all", "dependent", "uses", "and", "definitions", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "chain", "discovery", "was", "aborted", "." ]

[ "i386", "\"Building chain #%d...\\n\"", "\"Aborted chain #%d discovery\\n\"", "\"Collected chain #%d...\\n\"", "\" insns: \"", "\"\"", "\" defs to convert: \"", "0", "\"%sr%d\"", "\", \"", "\"\\n\"" ]

i386-features1

build

i386

CPU

GCC

16,533

217

1

[]

[ "<s>", "static", "bool", "m32r_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "m32r" ]

m32r

m32r_mode_dependent_address_p

m32r

MPU

GCC

16,534

28

1

[]

[ "<s>", "static", "void", "ix86_pad_short_function", "(", "void", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "{", "rtx_insn", "*", "ret", "=", "BB_END", "(", "e", "->", "src", ")", ";", "if", "(", "JUMP_P", "(", "ret", ")", "&&", "ANY_RETURN_P", "(", "PATTERN", "(", "ret", ")", ")", ")", "{", "int", "insn_count", "=", "ix86_count_insn", "(", "e", "->", "src", ")", ";", "if", "(", "insn_count", "<", "4", ")", "{", "rtx_insn", "*", "insn", "=", "ret", ";", "while", "(", "insn", "&&", "(", "!", "NOTE_P", "(", "insn", ")", "||", "NOTE_KIND", "(", "insn", ")", "!=", "NOTE_INSN_EPILOGUE_BEG", ")", ")", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "if", "(", "!", "insn", ")", "insn", "=", "ret", ";", "insn_count", "=", "2", "*", "(", "4", "-", "insn_count", ")", ";", "emit_insn_before", "(", "gen_nops", "(", "GEN_INT", "(", "insn_count", ")", ")", ",", "insn", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Pad", "short", "function", "to", "4", "instructions", "." ]

[ "i386", "4", "2", "4" ]

i386

ix86_pad_short_function

i386

CPU

GCC

16,535

139

1

[]

[ "<s>", "void", "SparcAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", ";", "case", "SP", "::", "GETPCX", ":", "LowerGETPCXAndEmitMCInsts", "(", "MI", ",", "getSubtargetInfo", "(", ")", ")", ";", "return", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "MCInst", "TmpInst", ";", "LowerSparcMachineInstrToMCInst", "(", "I", ",", "TmpInst", ",", "*", "this", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::GETPCX", "Sparc" ]

SparcAsmPrinter10

EmitInstruction

Sparc

CPU

LLVM

16,536

110

1

[]

[ "<s>", "bool", "PatmosInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "assert", "(", "AllowModify", "||", "(", "TBB", "==", "0", "&&", "FBB", "==", "0", "&&", "Cond", ".", "size", "(", ")", "==", "0", ")", ")", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", "||", "I", "->", "isPseudo", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", "||", "I", "->", "isIndirectBranch", "(", ")", ")", "return", "true", ";", "if", "(", "!", "isPredicated", "(", "*", "I", ")", ")", "{", "if", "(", "!", "I", "->", "isUnconditionalBranch", "(", ")", ")", "fixOpcodeForGuard", "(", "*", "I", ")", ";", "TBB", "=", "getBranchTarget", "(", "&", "*", "I", ")", ";", "if", "(", "AllowModify", ")", "{", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "}", "continue", ";", "}", "if", "(", "isPredicated", "(", "*", "I", ")", ")", "{", "if", "(", "!", "I", "->", "isConditionalBranch", "(", ")", ")", "fixOpcodeForGuard", "(", "*", "I", ")", ";", "if", "(", "Cond", ".", "size", "(", ")", ">", "0", ")", "return", "true", ";", "int", "i", "=", "I", "->", "findFirstPredOperandIdx", "(", ")", ";", "assert", "(", "i", "!=", "-", "1", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "i", "+", "1", ")", ")", ";", "if", "(", "TBB", ")", "FBB", "=", "TBB", ";", "TBB", "=", "getBranchTarget", "(", "&", "*", "I", ")", ";", "continue", ";", "}", "llvm_unreachable", "(", "\"AnalyzeBranch error.\"", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "Patmos", "Patmos", "0", "0", "0", "0", "1", "1", "\"AnalyzeBranch error.\"" ]

PatmosInstrInfo1

analyzeBranch

Patmos

VLIW

LLVM

16,537

301

1

[]

[ "<s>", "static", "void", "frame_related_constant_load", "(", "rtx", "reg", ",", "HOST_WIDE_INT", "constant", ",", "bool", "related", ")", "{", "rtx", "insn", ";", "rtx", "cst", "=", "GEN_INT", "(", "constant", ")", ";", "if", "(", "constant", ">=", "-", "32768", "&&", "constant", "<", "65536", ")", "insn", "=", "emit_move_insn", "(", "reg", ",", "cst", ")", ";", "else", "{", "insn", "=", "emit_insn", "(", "gen_movsi_high", "(", "reg", ",", "cst", ")", ")", ";", "if", "(", "related", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_movsi_low", "(", "reg", ",", "reg", ",", "cst", ")", ")", ";", "}", "if", "(", "related", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "code", "to", "load", "a", "constant", "CONSTANT", "into", "register", "REG", ";", "setting", "RTX_FRAME_RELATED_P", "on", "all", "insns", "we", "generate", "if", "RELATED", "is", "true", ".", "Make", "sure", "that", "the", "insns", "we", "generate", "need", "not", "be", "split", "." ]

[ "bfin", "32768", "65536", "1", "1" ]

bfin2

frame_related_constant_load

bfin

DSP

GCC

16,538

97

1

[]

[ "<s>", "static", "bool", "rs6000_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "TARGET_IEEEQUAD", "&&", "mode", "==", "TFmode", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 long double\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "!", "type", ")", "return", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "int_size_in_bytes", "(", "type", ")", "<", "0", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: variable size\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TARGET_32BIT", "&&", "!", "TARGET_ALTIVEC_ABI", "&&", "ALTIVEC_VECTOR_MODE", "(", "mode", ")", ")", "{", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: AltiVec\\n\"", ")", ";", "return", "1", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">", "(", "TARGET_ALTIVEC_ABI", "?", "16", ":", "8", ")", ")", "{", "static", "bool", "warned_for_pass_big_vectors", "=", "false", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\"function_arg_pass_by_reference: synthetic vector\\n\"", ")", ";", "if", "(", "!", "warned_for_pass_big_vectors", ")", "{", "warning", "(", "0", ",", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", ")", ";", "warned_for_pass_big_vectors", "=", "true", ";", "}", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "A", "C", "expression", "that", "indicates", "when", "an", "argument", "must", "be", "passed", "by", "reference", ".", "If", "nonzero", "for", "an", "argument", ",", "a", "copy", "of", "that", "argument", "is", "made", "in", "memory", "and", "a", "pointer", "to", "the", "argument", "is", "passed", "instead", "of", "the", "argument", "itself", ".", "The", "pointer", "is", "passed", "in", "whatever", "way", "is", "appropriate", "for", "passing", "a", "pointer", "to", "that", "type", ".", "Under", "V.4", ",", "aggregates", "and", "long", "double", "are", "passed", "by", "reference", ".", "As", "an", "extension", "to", "all", "32-bit", "ABIs", ",", "AltiVec", "vectors", "are", "passed", "by", "reference", "unless", "the", "AltiVec", "vector", "extension", "ABI", "is", "in", "force", ".", "As", "an", "extension", "to", "all", "ABIs", ",", "variable", "sized", "types", "are", "passed", "by", "reference", "." ]

[ "rs6000", "\"function_arg_pass_by_reference: V4 long double\\n\"", "1", "0", "\"function_arg_pass_by_reference: V4 aggregate\\n\"", "1", "0", "\"function_arg_pass_by_reference: variable size\\n\"", "1", "\"function_arg_pass_by_reference: AltiVec\\n\"", "1", "16", "8", "\"function_arg_pass_by_reference: synthetic vector\\n\"", "0", "\"GCC vector passed by reference: \"", "\"non-standard ABI extension with no compatibility guarantee\"", "1", "0" ]

rs60004

rs6000_pass_by_reference

rs6000

CPU

GCC

16,539

202

1

[]

[ "<s>", "tree", "resolve_overloaded_builtin", "(", "location_t", "location", ",", "unsigned", "int", "code", ",", "vec", "<", "tree", ",", "va_gc", ">", "*", "arglist", ")", "{", "if", "(", "code", ">=", "vec_safe_length", "(", "registered_functions", ")", ")", "return", "NULL_TREE", ";", "registered_function", "&", "rfn", "=", "*", "(", "*", "registered_functions", ")", "[", "code", "]", ";", "if", "(", "rfn", ".", "overloaded_p", ")", "return", "function_resolver", "(", "location", ",", "rfn", ".", "instance", ",", "rfn", ".", "decl", ",", "*", "arglist", ")", ".", "resolve", "(", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "If", "we", "'re", "implementing", "manual", "overloading", ",", "check", "whether", "the", "SVE", "function", "with", "subcode", "CODE", "is", "overloaded", ",", "and", "if", "so", "attempt", "to", "determine", "the", "corresponding", "non-overloaded", "function", ".", "The", "call", "occurs", "at", "location", "LOCATION", "and", "has", "the", "arguments", "given", "by", "ARGLIST", ".", "If", "the", "call", "is", "erroneous", ",", "report", "an", "appropriate", "error", "and", "return", "error_mark_node", ".", "Otherwise", ",", "if", "the", "function", "is", "overloaded", ",", "return", "the", "decl", "of", "the", "non-overloaded", "function", ".", "Return", "NULL_TREE", "otherwise", ",", "indicating", "that", "the", "call", "should", "be", "processed", "in", "the", "normal", "way", "." ]

[ "aarch64" ]

aarch64-sve-builtins

resolve_overloaded_builtin

aarch64

CPU

GCC

16,540

76

1

[]

[ "<s>", "const", "SystemZSubtarget", "*", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

SystemZTargetMachine10

getSubtargetImpl

SystemZ

CPU

LLVM

16,541

17

1

[]

[ "<s>", "static", "void", "rs6000_emit_dot_insn", "(", "rtx", "dst", ",", "rtx", "src", ",", "int", "dot", ",", "rtx", "ccreg", ")", "{", "if", "(", "dot", "==", "0", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "return", ";", "}", "if", "(", "cc_reg_not_cr0_operand", "(", "ccreg", ",", "CCmode", ")", ")", "{", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "emit_move_insn", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "dst", ",", "const0_rtx", ")", ")", ";", "return", ";", "}", "rtx", "ccset", "=", "gen_rtx_SET", "(", "ccreg", ",", "gen_rtx_COMPARE", "(", "CCmode", ",", "src", ",", "const0_rtx", ")", ")", ";", "if", "(", "dot", "==", "1", ")", "{", "rtx", "clobber", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "dst", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "clobber", ")", ")", ")", ";", "}", "else", "{", "rtx", "set", "=", "gen_rtx_SET", "(", "dst", ",", "src", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "ccset", ",", "set", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "potentially", "record-form", "instruction", ",", "setting", "DST", "from", "SRC", ".", "If", "DOT", "is", "0", ",", "that", "is", "all", ";", "otherwise", ",", "set", "CCREG", "to", "the", "result", "of", "the", "signed", "comparison", "of", "DST", "with", "zero", ".", "If", "DOT", "is", "1", ",", "the", "generated", "RTL", "does", "n't", "care", "about", "the", "DST", "result", ";", "if", "DOT", "is", "2", ",", "it", "does", ".", "If", "CCREG", "is", "CR0", "do", "a", "single", "dot", "insn", "(", "as", "a", "PARALLEL", ")", ";", "otherwise", ",", "do", "a", "SET", "and", "a", "separate", "COMPARE", "." ]

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

rs60005

rs6000_emit_dot_insn

rs6000

CPU

GCC

16,542

151

1

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitHeader", "(", "Module", "&", "M", ",", "raw_ostream", "&", "O", ",", "const", "NVPTXSubtarget", "&", "STI", ")", "{", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"// Generated by LLVM NVPTX Back-End\\n\"", ";", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"\\n\"", ";", "unsigned", "PTXVersion", "=", "STI", ".", "getPTXVersion", "(", ")", ";", "O", "<<", "\".version \"", "<<", "(", "PTXVersion", "/", "10", ")", "<<", "\".\"", "<<", "(", "PTXVersion", "%", "10", ")", "<<", "\"\\n\"", ";", "O", "<<", "\".target \"", ";", "O", "<<", "STI", ".", "getTargetName", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "if", "(", "NTM", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "NVCL", ")", "O", "<<", "\", texmode_independent\"", ";", "bool", "HasFullDebugInfo", "=", "false", ";", "for", "(", "DICompileUnit", "*", "CU", ":", "M", ".", "debug_compile_units", "(", ")", ")", "{", "switch", "(", "CU", "->", "getEmissionKind", "(", ")", ")", "{", "case", "DICompileUnit", "::", "NoDebug", ":", "case", "DICompileUnit", "::", "DebugDirectivesOnly", ":", "break", ";", "case", "DICompileUnit", "::", "LineTablesOnly", ":", "case", "DICompileUnit", "::", "FullDebug", ":", "HasFullDebugInfo", "=", "true", ";", "break", ";", "}", "if", "(", "HasFullDebugInfo", ")", "break", ";", "}", "if", "(", "MMI", "&&", "MMI", "->", "hasDebugInfo", "(", ")", "&&", "HasFullDebugInfo", ")", "O", "<<", "\", debug\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\".address_size \"", ";", "if", "(", "NTM", ".", "is64Bit", "(", ")", ")", "O", "<<", "\"64\"", ";", "else", "O", "<<", "\"32\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Emit", "the", "header", "for", "this", "unit", ",", "not", "including", "the", "initial", "length", "field", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "\"//\\n\"", "\"// Generated by LLVM NVPTX Back-End\\n\"", "\"//\\n\"", "\"\\n\"", "\".version \"", "10", "\".\"", "10", "\"\\n\"", "\".target \"", "NVPTX", "NVPTX", "NVPTX::NVCL", "\", texmode_independent\"", "\", debug\"", "\"\\n\"", "\".address_size \"", "\"64\"", "\"32\"", "\"\\n\"", "\"\\n\"" ]

NVPTXAsmPrinter15

emitHeader

NVPTX

GPU

LLVM

16,543

220

1

[]

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

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

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

X86DiscriminateMemOps (2)

runOnMachineFunction

X86

CPU

LLVM

16,544

464

1

[]

[ "<s>", "void", "aarch64_expand_call", "(", "rtx", "result", ",", "rtx", "mem", ",", "bool", "sibcall", ")", "{", "rtx", "call", ",", "callee", ",", "tmp", ";", "rtvec", "vec", ";", "machine_mode", "mode", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "callee", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "mode", "=", "GET_MODE", "(", "callee", ")", ";", "gcc_assert", "(", "mode", "==", "Pmode", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "callee", ")", "?", "(", "aarch64_is_long_call_p", "(", "callee", ")", "||", "aarch64_is_noplt_call_p", "(", "callee", ")", ")", ":", "!", "REG_P", "(", "callee", ")", ")", "XEXP", "(", "mem", ",", "0", ")", "=", "force_reg", "(", "mode", ",", "callee", ")", ";", "call", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "mem", ",", "const0_rtx", ")", ";", "if", "(", "result", "!=", "NULL_RTX", ")", "call", "=", "gen_rtx_SET", "(", "result", ",", "call", ")", ";", "if", "(", "sibcall", ")", "tmp", "=", "ret_rtx", ";", "else", "tmp", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNUM", ")", ")", ";", "vec", "=", "gen_rtvec", "(", "2", ",", "call", ",", "tmp", ")", ";", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vec", ")", ";", "aarch64_emit_call_insn", "(", "call", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "by", "the", "call", "expanders", "of", "the", "machine", "description", ".", "RESULT", "is", "the", "register", "in", "which", "the", "result", "is", "returned", ".", "It", "'s", "NULL", "for", "``", "call", "''", "and", "``", "sibcall", "''", ".", "MEM", "is", "the", "location", "of", "the", "function", "call", ".", "SIBCALL", "indicates", "whether", "this", "function", "call", "is", "normal", "call", "or", "sibling", "call", ".", "It", "will", "generate", "different", "pattern", "accordingly", "." ]

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

aarch645

aarch64_expand_call

aarch64

CPU

GCC

16,545

171

1

[]

[ "<s>", "int", "ARMBaseInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "SDNode", "*", "DefNode", ",", "unsigned", "DefIdx", ",", "SDNode", "*", "UseNode", ",", "unsigned", "UseIdx", ")", "const", "{", "if", "(", "!", "DefNode", "->", "isMachineOpcode", "(", ")", ")", "return", "1", ";", "const", "TargetInstrDesc", "&", "DefTID", "=", "get", "(", "DefNode", "->", "getMachineOpcode", "(", ")", ")", ";", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "DefTID", ".", "mayLoad", "(", ")", "?", "3", ":", "1", ";", "if", "(", "!", "UseNode", "->", "isMachineOpcode", "(", ")", ")", "{", "int", "Latency", "=", "ItinData", "->", "getOperandCycle", "(", "DefTID", ".", "getSchedClass", "(", ")", ",", "DefIdx", ")", ";", "if", "(", "Subtarget", ".", "isCortexA9", "(", ")", ")", "return", "Latency", "<=", "2", "?", "1", ":", "Latency", "-", "1", ";", "else", "return", "Latency", "<=", "3", "?", "1", ":", "Latency", "-", "2", ";", "}", "const", "TargetInstrDesc", "&", "UseTID", "=", "get", "(", "UseNode", "->", "getMachineOpcode", "(", ")", ")", ";", "const", "MachineSDNode", "*", "DefMN", "=", "dyn_cast", "<", "MachineSDNode", ">", "(", "DefNode", ")", ";", "unsigned", "DefAlign", "=", "!", "DefMN", "->", "memoperands_empty", "(", ")", "?", "(", "*", "DefMN", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "const", "MachineSDNode", "*", "UseMN", "=", "dyn_cast", "<", "MachineSDNode", ">", "(", "UseNode", ")", ";", "unsigned", "UseAlign", "=", "!", "UseMN", "->", "memoperands_empty", "(", ")", "?", "(", "*", "UseMN", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "int", "Latency", "=", "getOperandLatency", "(", "ItinData", ",", "DefTID", ",", "DefIdx", ",", "DefAlign", ",", "UseTID", ",", "UseIdx", ",", "UseAlign", ")", ";", "if", "(", "Latency", ">", "1", "&&", "(", "Subtarget", ".", "isCortexA8", "(", ")", "||", "Subtarget", ".", "isCortexA9", "(", ")", ")", ")", "{", "switch", "(", "DefTID", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "LDRBrs", ":", "{", "unsigned", "ShOpVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "DefNode", "->", "getOperand", "(", "2", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "ShImm", "=", "ARM_AM", "::", "getAM2Offset", "(", "ShOpVal", ")", ";", "if", "(", "ShImm", "==", "0", "||", "(", "ShImm", "==", "2", "&&", "ARM_AM", "::", "getAM2ShiftOpc", "(", "ShOpVal", ")", "==", "ARM_AM", "::", "lsl", ")", ")", "--", "Latency", ";", "break", ";", "}", "case", "ARM", "::", "t2LDRs", ":", "case", "ARM", "::", "t2LDRBs", ":", "case", "ARM", "::", "t2LDRHs", ":", "case", "ARM", "::", "t2LDRSHs", ":", "{", "unsigned", "ShAmt", "=", "cast", "<", "ConstantSDNode", ">", "(", "DefNode", "->", "getOperand", "(", "2", ")", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "ShAmt", "==", "0", "||", "ShAmt", "==", "2", ")", "--", "Latency", ";", "break", ";", "}", "}", "}", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

[ "ARM", "ARM", "1", "3", "1", "2", "1", "1", "3", "1", "2", "0", "0", "1", "ARM::LDRrs", "ARM::LDRBrs", "2", "ARM_AM::getAM2Offset", "0", "2", "ARM_AM::getAM2ShiftOpc", "ARM_AM::lsl", "ARM::t2LDRs", "ARM::t2LDRBs", "ARM::t2LDRHs", "ARM::t2LDRSHs", "2", "0", "2" ]

ARMBaseInstrInfo54

getOperandLatency

ARM

CPU

LLVM

16,546

409

1

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "emitAlignment", "(", "std", "::", "max", "(", "MF", "->", "getAlignment", "(", ")", ",", "MIPS_NACL_BUNDLE_ALIGN", ")", ")", ";", "if", "(", "Subtarget", "->", "inMicroMipsMode", "(", ")", ")", "{", "TS", ".", "emitDirectiveSetMicroMips", "(", ")", ";", "TS", ".", "setUsesMicroMips", "(", ")", ";", "TS", ".", "updateABIInfo", "(", "*", "Subtarget", ")", ";", "}", "else", "TS", ".", "emitDirectiveSetNoMicroMips", "(", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "TS", ".", "emitDirectiveSetMips16", "(", ")", ";", "else", "TS", ".", "emitDirectiveSetNoMips16", "(", ")", ";", "TS", ".", "emitDirectiveEnt", "(", "*", "CurrentFnSym", ")", ";", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

MipsAsmPrinter

emitFunctionEntryLabel

Mips

CPU

LLVM

16,547

113

1

[]

[ "<s>", "bool", "isFPVectorizationPotentiallyUnsafe", "(", ")", "{", "return", "!", "ST", "->", "isTargetDarwin", "(", ")", ";", "}", "</s>" ]

[ "Indicate", "that", "it", "is", "potentially", "unsafe", "to", "automatically", "vectorize", "floating-point", "operations", "because", "the", "semantics", "of", "vector", "and", "scalar", "floating-point", "semantics", "may", "differ", "." ]

[ "ARM" ]

ARMTargetTransformInfo

isFPVectorizationPotentiallyUnsafe

ARM

CPU

LLVM

16,548

14

1

[]

[ "<s>", "unsigned", "rvexFunctionInfo", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "GlobalBaseReg", ")", "return", "GlobalBaseReg", ";", "if", "(", "rvexFixGlobalBaseReg", ")", "return", "GlobalBaseReg", "=", "rvex", "::", "R0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "RC", "=", "(", "const", "TargetRegisterClass", "*", ")", "&", "rvex", "::", "CPURegsRegClass", ";", "return", "GlobalBaseReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "rvex", "rvex::R0", "rvex::CPURegsRegClass" ]

rvexMachineFunction

getGlobalBaseReg

rvex

VLIW

LLVM

16,549

57

1

[]

[ "<s>", "bool", "aarch64_sve_sqadd_sqsub_immediate_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "negate_p", ")", "{", "if", "(", "!", "aarch64_sve_arith_immediate_p", "(", "mode", ",", "x", ",", "negate_p", ")", ")", "return", "false", ";", "rtx", "elt", "=", "unwrap_const_vec_duplicate", "(", "x", ")", ";", "return", "negate_p", "==", "(", "INTVAL", "(", "elt", ")", "<", "0", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "immediate", "for", "the", "SVE", "SQADD", "and", "SQSUB", "instructions", "when", "applied", "to", "mode", "MODE", ".", "Negate", "X", "first", "if", "NEGATE_P", "is", "true", "." ]

[ "aarch64", "0" ]

aarch64

aarch64_sve_sqadd_sqsub_immediate_p

aarch64

CPU

GCC

16,550

49

1

[]

[ "<s>", "bool", "MSP430InstrInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "0", "1", "MSP430::PUSH16r" ]

MSP430InstrInfo14

spillCalleeSavedRegisters

MSP430

MPU

LLVM

16,551

171

1

[]

[ "<s>", "bool", "MBlazePassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", ".", "add", "(", "createMBlazeDelaySlotFillerPass", "(", "getMBlazeTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]

MBlazeTargetMachine2

addPreEmitPass

MBlaze

MPU

LLVM

16,552

23

1

[]

[ "<s>", "static", "void", "ix86_store_bounds", "(", "rtx", "ptr", ",", "rtx", "slot", ",", "rtx", "bounds", ",", "rtx", "slot_no", ")", "{", "rtx", "addr", ";", "addr", "=", "ix86_get_arg_address_for_bt", "(", "slot", ",", "slot_no", ",", "stack_pointer_rtx", ")", ";", "if", "(", "!", "ptr", ")", "{", "gcc_assert", "(", "MEM_P", "(", "slot", ")", ")", ";", "ptr", "=", "copy_addr_to_reg", "(", "slot", ")", ";", "}", "gcc_assert", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "bounds", ")", ")", ")", ";", "if", "(", "!", "register_operand", "(", "bounds", ",", "BNDmode", ")", ")", "bounds", "=", "copy_to_mode_reg", "(", "BNDmode", ",", "bounds", ")", ";", "emit_insn", "(", "BNDmode", "==", "BND64mode", "?", "gen_bnd64_stx", "(", "addr", ",", "ptr", ",", "bounds", ")", ":", "gen_bnd32_stx", "(", "addr", ",", "ptr", ",", "bounds", ")", ")", ";", "}", "</s>" ]

[ "Expand", "pass", "uses", "this", "hook", "to", "store", "BOUNDS", "for", "call", "argument", "PTR", "passed", "in", "SLOT", "in", "case", "BOUNDS", "are", "not", "passed", "in", "a", "register", ".", "If", "SLOT", "is", "a", "memory", ",", "then", "BOUNDS", "are", "stored", "as", "for", "regular", "pointer", "stored", "in", "memory", ".", "PTR", "may", "be", "NULL", "in", "case", "SLOT", "is", "a", "memory", ".", "In", "such", "case", "value", "of", "PTR", "(", "if", "required", ")", "may", "be", "loaded", "from", "SLOT", ".", "If", "SLOT", "is", "NULL", "or", "a", "register", "then", "SLOT_NO", "is", "an", "integer", "constant", "holding", "number", "of", "the", "target", "dependent", "special", "slot", "which", "should", "be", "used", "to", "store", "BOUNDS", "." ]

[ "i386" ]

i3864

ix86_store_bounds

i386

CPU

GCC

16,553

109

1

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2STRi12", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "storeRegToStackSlot", "(", "MBB", ",", "I", ",", "SrcReg", ",", "isKill", ",", "FI", ",", "RC", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegisterClass", "ARM::t2STRi12", "0", "ARM" ]

Thumb2InstrInfo49

storeRegToStackSlot

ARM

CPU

LLVM

16,554

126

1

[]

[ "<s>", "SDValue", "LC2200TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "analyzeOutputArgs", "(", "DAG", ".", "getMachineFunction", "(", ")", ",", "CCInfo", ",", "Outs", ",", "true", ",", "nullptr", ")", ";", "SDValue", "Glue", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i32", "&&", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", ")", "{", "llvm_unreachable", "(", "\"not supported\"", ")", ";", "}", "else", "{", "Val", "=", "convertValVTToLocVT", "(", "DAG", ",", "Val", ",", "VA", ",", "DL", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Glue", ")", ";", "Glue", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Glue", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Glue", ")", ";", "}", "const", "Function", "&", "Func", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "if", "(", "Func", ".", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "llvm_unreachable", "(", "\"interrupts not supported\"", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "LC2200ISD", "::", "RET", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "LC2200", "LC2200", "ISD::OutputArg", "16", "4", "1", "0", "\"Can only return in registers!\"", "MVT::i32", "MVT::f64", "\"not supported\"", "1", "0", "\"interrupt\"", "\"interrupts not supported\"", "LC2200ISD::RET", "MVT::Other" ]

LC2200ISelLowering

LowerReturn

LC2200

CPU

LLVM

16,555

332

1

[]

[ "<s>", "static", "unsigned", "int", "move_elim_pass", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "ninsn", ";", "rtx", "prev", "=", "NULL_RTX", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "ninsn", ")", "{", "rtx", "set", ";", "ninsn", "=", "next_nonnote_nondebug_insn", "(", "insn", ")", ";", "if", "(", "(", "set", "=", "single_set", "(", "insn", ")", ")", "==", "NULL_RTX", ")", "{", "prev", "=", "NULL_RTX", ";", "continue", ";", "}", "if", "(", "prev", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "prev", ")", ",", "SET_SRC", "(", "set", ")", ")", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_SRC", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_DEST", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_SRC", "(", "set", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_DEST", "(", "set", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Delete insn %d because it is redundant\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "delete_insn", "(", "insn", ")", ";", "prev", "=", "NULL_RTX", ";", "}", "else", "prev", "=", "set", ";", "}", "if", "(", "dump_file", ")", "print_rtl_with_bb", "(", "dump_file", ",", "get_insns", "(", ")", ",", "TDF_NONE", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Redundant", "move", "elimination", "pass", ".", "Must", "be", "run", "after", "the", "basic", "block", "reordering", "pass", "for", "the", "best", "effect", "." ]

[ "rl78", "\" Delete insn %d because it is redundant\\n\"", "0" ]

rl78

move_elim_pass

rl78

MPU

GCC

16,556

184

1

[]

[ "<s>", "void", "AArch64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ",", "Mnemonic", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "LdStNInstrDesc", "*", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "AArch64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "AArch64InstPrinter", "::", "printInst", "(", "MI", ",", "O", ",", "Annot", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "AArch64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "AArch64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "AArch64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "AArch64" ]

AArch64InstPrinter1

printInst

AArch64

CPU

LLVM

16,557

331

1

[]

[ "<s>", "void", "PPCInstrInfo", "::", "genAlternativeCodeSequence", "(", "MachineInstr", "&", "Root", ",", "MachineCombinerPattern", "Pattern", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "InsInstrs", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DelInstrs", ",", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "InstrIdxForVirtReg", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "case", "MachineCombinerPattern", "::", "REASSOC_XY_AMM_BMM", ":", "case", "MachineCombinerPattern", "::", "REASSOC_XMM_AMM_BMM", ":", "reassociateFMA", "(", "Root", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstrIdxForVirtReg", ")", ";", "break", ";", "default", ":", "TargetInstrInfo", "::", "genAlternativeCodeSequence", "(", "Root", ",", "Pattern", ",", "InsInstrs", ",", "DelInstrs", ",", "InstrIdxForVirtReg", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "When", "getMachineCombinerPatterns", "(", ")", "finds", "potential", "patterns", ",", "this", "function", "generates", "the", "instructions", "that", "could", "replace", "the", "original", "code", "sequence", "." ]

[ "PowerPC", "PPC" ]

PPCInstrInfo128

genAlternativeCodeSequence

PowerPC

CPU

LLVM

16,558

90

1

[]

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

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

[ "Mips" ]

MipsAsmBackend11

mayNeedRelaxation

Mips

CPU

LLVM

16,559

14

1

[]

[ "<s>", "static", "machine_mode", "aarch64_c_mode_for_suffix", "(", "char", "suffix", ")", "{", "if", "(", "suffix", "==", "'q'", ")", "return", "TFmode", ";", "return", "VOIDmode", ";", "}", "</s>" ]

[ "Target", "hook", "for", "c_mode_for_suffix", "." ]

[ "aarch64" ]

aarch64

aarch64_c_mode_for_suffix

aarch64

CPU

GCC

16,560

21

1

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "markup", "(", "\"<reg:\"", ")", "<<", "'%'", "<<", "getRegisterName", "(", "RegNo", ")", "<<", "markup", "(", "\">\"", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "X86", "X86", "\"<reg:\"", "\">\"" ]

X86ATTInstPrinter (2)

printRegName

X86

CPU

LLVM

16,561

34

1

[]

[ "<s>", "unsigned", "getExplicitKernelArgOffset", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "isAmdHsaOrMesa", "(", "F", ")", "?", "0", ":", "36", ";", "}", "</s>" ]

[ "Returns", "the", "offset", "in", "bytes", "from", "the", "start", "of", "the", "input", "buffer", "of", "the", "first", "explicit", "kernel", "argument", "." ]

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

AMDGPUSubtarget1

getExplicitKernelArgOffset

AMDGPU

GPU

LLVM

16,562

21

1

[]

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

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

[ "Sparc", "Sparc", "Sparc" ]

SparcInstPrinter14

printInst

Sparc

CPU

LLVM

16,563

51

1

[]

[ "<s>", "unsigned", "Cpu0MCCodeEmitter", "::", "getJumpTargetOpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getJumpTargetOpValue expects only expressions\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Cpu0", "::", "fixup_Cpu0_24", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getJumpTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "jump", "target", "operand", "." ]

[ "Cpu0", "Cpu0", "\"getJumpTargetOpValue expects only expressions\"", "0", "Cpu0::fixup_Cpu0_24", "0" ]

Cpu0MCCodeEmitter1

getJumpTargetOpValue

Cpu0

CPU

LLVM

16,564

96

1

[]

[ "<s>", "static", "HOST_WIDE_INT", "mmix_static_rtx_alignment", "(", "machine_mode", "mode", ")", "{", "return", "MAX", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ",", "32", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_STATIC_RTX_ALIGNMENT", "." ]

[ "mmix", "32" ]

mmix

mmix_static_rtx_alignment

mmix

CPU

GCC

16,565

20

1

[]

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

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

[ "AMDGPU", "R600" ]

AMDGPUSubtarget

getRegisterInfo

AMDGPU

GPU

LLVM

16,566

18

1

[]

[ "<s>", "void", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "override", "{", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "SPIRV" ]

SPIRVAsmBackend

relaxInstruction

SPIRV

Virtual ISA

LLVM

16,567

16

1

[]

[ "<s>", "static", "void", "arm_init_builtin", "(", "unsigned", "int", "fcode", ",", "arm_builtin_datum", "*", "d", ",", "const", "char", "*", "prefix", ")", "{", "bool", "print_type_signature_p", "=", "false", ";", "char", "type_signature", "[", "SIMD_MAX_BUILTIN_ARGS", "]", "=", "{", "0", "}", ";", "char", "namebuf", "[", "60", "]", ";", "tree", "ftype", "=", "NULL", ";", "tree", "fndecl", "=", "NULL", ";", "d", "->", "fcode", "=", "fcode", ";", "int", "op_num", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", "-", "1", ";", "int", "arg_num", "=", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", "?", "op_num", "+", "1", ":", "op_num", ";", "tree", "return_type", "=", "void_type_node", ",", "args", "=", "void_list_node", ";", "tree", "eltype", ";", "for", "(", ";", "op_num", ">=", "0", ";", "arg_num", "--", ",", "op_num", "--", ")", "{", "machine_mode", "op_mode", "=", "insn_data", "[", "d", "->", "code", "]", ".", "operand", "[", "op_num", "]", ".", "mode", ";", "enum", "arm_type_qualifiers", "qualifiers", "=", "d", "->", "qualifiers", "[", "arg_num", "]", ";", "if", "(", "qualifiers", "&", "qualifier_unsigned", ")", "{", "type_signature", "[", "arg_num", "]", "=", "'u'", ";", "print_type_signature_p", "=", "true", ";", "}", "else", "if", "(", "qualifiers", "&", "qualifier_poly", ")", "{", "type_signature", "[", "arg_num", "]", "=", "'p'", ";", "print_type_signature_p", "=", "true", ";", "}", "else", "type_signature", "[", "arg_num", "]", "=", "'s'", ";", "if", "(", "qualifiers", "&", "qualifier_internal", ")", "continue", ";", "if", "(", "qualifiers", "&", "qualifier_map_mode", ")", "op_mode", "=", "d", "->", "mode", ";", "if", "(", "qualifiers", "&", "qualifier_pointer", "&&", "VECTOR_MODE_P", "(", "op_mode", ")", ")", "op_mode", "=", "GET_MODE_INNER", "(", "op_mode", ")", ";", "eltype", "=", "arm_simd_builtin_type", "(", "op_mode", ",", "(", "qualifiers", "&", "qualifier_unsigned", ")", "!=", "0", ",", "(", "qualifiers", "&", "qualifier_poly", ")", "!=", "0", ")", ";", "gcc_assert", "(", "eltype", "!=", "NULL", ")", ";", "if", "(", "qualifiers", "&", "qualifier_const", ")", "eltype", "=", "build_qualified_type", "(", "eltype", ",", "TYPE_QUAL_CONST", ")", ";", "if", "(", "qualifiers", "&", "qualifier_pointer", ")", "eltype", "=", "build_pointer_type", "(", "eltype", ")", ";", "if", "(", "arg_num", "==", "0", ")", "return_type", "=", "eltype", ";", "else", "args", "=", "tree_cons", "(", "NULL_TREE", ",", "eltype", ",", "args", ")", ";", "}", "ftype", "=", "build_function_type", "(", "return_type", ",", "args", ")", ";", "gcc_assert", "(", "ftype", "!=", "NULL", ")", ";", "if", "(", "print_type_signature_p", "&&", "IN_RANGE", "(", "fcode", ",", "ARM_BUILTIN_VFP_BASE", ",", "ARM_BUILTIN_ACLE_BASE", "-", "1", ")", ")", "snprintf", "(", "namebuf", ",", "sizeof", "(", "namebuf", ")", ",", "\"%s_%s_%s\"", ",", "prefix", ",", "d", "->", "name", ",", "type_signature", ")", ";", "else", "snprintf", "(", "namebuf", ",", "sizeof", "(", "namebuf", ")", ",", "\"%s_%s\"", ",", "prefix", ",", "d", "->", "name", ")", ";", "fndecl", "=", "add_builtin_function", "(", "namebuf", ",", "ftype", ",", "fcode", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL_TREE", ")", ";", "arm_builtin_decls", "[", "fcode", "]", "=", "fndecl", ";", "}", "</s>" ]

[ "Set", "up", "a", "builtin", ".", "It", "will", "use", "information", "stored", "in", "the", "argument", "struct", "D", "to", "derive", "the", "builtin", "'s", "type", "signature", "and", "name", ".", "It", "will", "append", "the", "name", "in", "D", "to", "the", "PREFIX", "passed", "and", "use", "these", "to", "create", "a", "builtin", "declaration", "that", "is", "then", "stored", "in", "'arm_builtin_decls", "'", "under", "index", "FCODE", ".", "This", "FCODE", "is", "also", "written", "back", "to", "D", "for", "future", "use", "." ]

[ "arm", "0", "60", "1", "0", "1", "0", "0", "0", "0", "1", "\"%s_%s_%s\"", "\"%s_%s\"" ]

arm-builtins4

arm_init_builtin

arm

CPU

GCC

16,568

402

1

[]

[ "<s>", "std", "::", "unique_ptr", "<", "CSEConfigBase", ">", "MOSPassConfig", "::", "getCSEConfig", "(", ")", "const", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "std", "::", "make_unique", "<", "CSEConfigConstantOnly", ">", "(", ")", ";", "return", "std", "::", "make_unique", "<", "MOSCSEConfigFull", ">", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "CSEConfig", "object", "to", "use", "for", "the", "current", "optimization", "level", "." ]

[ "MOS", "MOS", "MOS" ]

MOSTargetMachine

getCSEConfig

MOS

MPU

LLVM

16,569

46

1

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "MFI", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "if", "(", "IsVarArg", ")", "{", "MVT", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "VarargVreg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "PtrVT", ")", ")", ";", "MFI", "->", "setVarargBufferVreg", "(", "VarargVreg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VarargVreg", ",", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstant", "(", "Ins", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ")", ";", "MFI", "->", "addParam", "(", "PtrVT", ")", ";", "}", "SmallVector", "<", "MVT", ",", "4", ">", "Params", ";", "SmallVector", "<", "MVT", ",", "4", ">", "Results", ";", "ComputeSignatureVTs", "(", "MF", ".", "getFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "Params", ",", "Results", ")", ";", "for", "(", "MVT", "VT", ":", "Results", ")", "MFI", "->", "addResult", "(", "VT", ")", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "ISD::InputArg", "\"WebAssembly doesn't support non-C calling conventions\"", "WebAssembly", "WebAssembly::ARGUMENTS", "ISD::InputArg", "\"WebAssembly hasn't implemented inalloca arguments\"", "\"WebAssembly hasn't implemented nest arguments\"", "\"WebAssembly hasn't implemented cons regs arguments\"", "\"WebAssembly hasn't implemented cons regs last arguments\"", "WebAssemblyISD::ARGUMENT", "MVT::i32", "WebAssemblyISD::ARGUMENT", "MVT::i32", "4", "4" ]

WebAssemblyISelLowering21

LowerFormalArguments

WebAssembly

Virtual ISA

LLVM

16,570

390

1

[]

[ "<s>", "static", "bool", "expand_vselect", "(", "rtx", "target", ",", "rtx", "op0", ",", "const", "unsigned", "char", "*", "perm", ",", "unsigned", "nelt", ",", "bool", "testing_p", ")", "{", "unsigned", "int", "i", ";", "rtx", "x", ",", "save_vconcat", ";", "int", "icode", ";", "if", "(", "vselect_insn", "==", "NULL_RTX", ")", "init_vselect_insn", "(", ")", ";", "x", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "1", ")", ";", "PUT_NUM_ELEM", "(", "XVEC", "(", "x", ",", "0", ")", ",", "nelt", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "XVECEXP", "(", "x", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "perm", "[", "i", "]", ")", ";", "save_vconcat", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", ";", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", "=", "op0", ";", "PUT_MODE", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "GET_MODE", "(", "target", ")", ")", ";", "SET_DEST", "(", "PATTERN", "(", "vselect_insn", ")", ")", "=", "target", ";", "icode", "=", "recog_memoized", "(", "vselect_insn", ")", ";", "if", "(", "icode", ">=", "0", "&&", "!", "testing_p", ")", "emit_insn", "(", "copy_rtx", "(", "PATTERN", "(", "vselect_insn", ")", ")", ")", ";", "SET_DEST", "(", "PATTERN", "(", "vselect_insn", ")", ")", "=", "const0_rtx", ";", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "vselect_insn", ")", ")", ",", "0", ")", "=", "save_vconcat", ";", "INSN_CODE", "(", "vselect_insn", ")", "=", "-", "1", ";", "return", "icode", ">=", "0", ";", "}", "</s>" ]

[ "Construct", "(", "set", "target", "(", "vec_select", "op0", "(", "parallel", "perm", ")", ")", ")", "and", "return", "true", "if", "that", "'s", "a", "valid", "instruction", "in", "the", "active", "ISA", "." ]

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

i386-expand

expand_vselect

i386

CPU

GCC

16,571

224

1

[]

[ "<s>", "void", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIV", ":", "{", "DebugLoc", "Empty", ";", "const", "DebugLoc", "&", "DL", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "if", "(", "DL", "!=", "Empty", ")", "errs", "(", ")", "<<", "\"Error at line \"", "<<", "DL", ".", "getLine", "(", ")", "<<", "\": \"", ";", "else", "errs", "(", ")", "<<", "\"Error: \"", ";", "errs", "(", ")", "<<", "\"Unsupport signed division for DAG: \"", ";", "Node", "->", "print", "(", "errs", "(", ")", ",", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"Please convert to unsigned div/mod.\\n\"", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "bpf_load_byte", ":", "case", "Intrinsic", "::", "bpf_load_half", ":", "case", "Intrinsic", "::", "bpf_load_word", ":", "{", "SDLoc", "DL", "(", "Node", ")", ";", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Skb", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "SDValue", "N3", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "R6Reg", "=", "CurDAG", "->", "getRegister", "(", "BPF", "::", "R6", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "DL", ",", "R6Reg", ",", "Skb", ",", "SDValue", "(", ")", ")", ";", "Node", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Chain", ",", "N1", ",", "R6Reg", ",", "N3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "BPF", "BPF", "\"== \"", "ISD::SDIV", "\"Error at line \"", "\": \"", "\"Error: \"", "\"Unsupport signed division for DAG: \"", "\"Please convert to unsigned div/mod.\\n\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::bpf_load_byte", "Intrinsic::bpf_load_half", "Intrinsic::bpf_load_word", "0", "1", "2", "3", "BPF::R6", "MVT::i64", "ISD::FrameIndex", "0", "BPF::MOV_rr" ]

BPFISelDAGToDAG12

Select

BPF

Virtual ISA

LLVM

16,572

393

1

[]

[ "<s>", "enum", "direction", "function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "TARGET_ARCH64", "&&", "type", "!=", "0", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "upward", ";", "return", "DEFAULT_FUNCTION_ARG_PADDING", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Handle", "the", "FUNCTION_ARG_PADDING", "macro", ".", "For", "the", "64", "bit", "ABI", "structs", "are", "always", "stored", "left", "shifted", "in", "their", "argument", "slot", "." ]

[ "sparc", "0" ]

sparc4

function_arg_padding

sparc

CPU

GCC

16,573

36

1

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "PPCHazardRecognizer970", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"PPC hazards don't support scoreboard lookahead\"", ")", ";", "const", "SDNode", "*", "Node", "=", "SU", "->", "getNode", "(", ")", "->", "getGluedMachineNode", "(", ")", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Node", "->", "getOpcode", "(", ")", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", "NoHazard", ";", "unsigned", "Opcode", "=", "Node", "->", "getMachineOpcode", "(", ")", ";", "if", "(", "NumIssued", "!=", "0", "&&", "(", "isFirst", "||", "isSingle", ")", ")", "return", "Hazard", ";", "if", "(", "isCracked", "&&", "NumIssued", ">", "2", ")", "return", "Hazard", ";", "switch", "(", "InstrType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction type!\"", ")", ";", "case", "PPCII", "::", "PPC970_FXU", ":", "case", "PPCII", "::", "PPC970_LSU", ":", "case", "PPCII", "::", "PPC970_FPU", ":", "case", "PPCII", "::", "PPC970_VALU", ":", "case", "PPCII", "::", "PPC970_VPERM", ":", "if", "(", "NumIssued", "==", "4", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_CRU", ":", "if", "(", "NumIssued", ">=", "2", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_BRU", ":", "break", ";", "}", "if", "(", "HasCTRSet", "&&", "(", "Opcode", "==", "PPC", "::", "BCTRL_Darwin", "||", "Opcode", "==", "PPC", "::", "BCTRL_SVR4", ")", ")", "return", "NoopHazard", ";", "if", "(", "isLoad", "&&", "NumStores", ")", "{", "unsigned", "LoadSize", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown load!\"", ")", ";", "case", "PPC", "::", "LBZ", ":", "case", "PPC", "::", "LBZU", ":", "case", "PPC", "::", "LBZX", ":", "case", "PPC", "::", "LBZ8", ":", "case", "PPC", "::", "LBZU8", ":", "case", "PPC", "::", "LBZX8", ":", "case", "PPC", "::", "LVEBX", ":", "LoadSize", "=", "1", ";", "break", ";", "case", "PPC", "::", "LHA", ":", "case", "PPC", "::", "LHAU", ":", "case", "PPC", "::", "LHAX", ":", "case", "PPC", "::", "LHZ", ":", "case", "PPC", "::", "LHZU", ":", "case", "PPC", "::", "LHZX", ":", "case", "PPC", "::", "LVEHX", ":", "case", "PPC", "::", "LHBRX", ":", "case", "PPC", "::", "LHA8", ":", "case", "PPC", "::", "LHAU8", ":", "case", "PPC", "::", "LHAX8", ":", "case", "PPC", "::", "LHZ8", ":", "case", "PPC", "::", "LHZU8", ":", "case", "PPC", "::", "LHZX8", ":", "LoadSize", "=", "2", ";", "break", ";", "case", "PPC", "::", "LFS", ":", "case", "PPC", "::", "LFSU", ":", "case", "PPC", "::", "LFSX", ":", "case", "PPC", "::", "LWZ", ":", "case", "PPC", "::", "LWZU", ":", "case", "PPC", "::", "LWZX", ":", "case", "PPC", "::", "LWA", ":", "case", "PPC", "::", "LWAX", ":", "case", "PPC", "::", "LVEWX", ":", "case", "PPC", "::", "LWBRX", ":", "case", "PPC", "::", "LWZ8", ":", "case", "PPC", "::", "LWZX8", ":", "LoadSize", "=", "4", ";", "break", ";", "case", "PPC", "::", "LFD", ":", "case", "PPC", "::", "LFDU", ":", "case", "PPC", "::", "LFDX", ":", "case", "PPC", "::", "LD", ":", "case", "PPC", "::", "LDU", ":", "case", "PPC", "::", "LDX", ":", "LoadSize", "=", "8", ";", "break", ";", "case", "PPC", "::", "LVX", ":", "case", "PPC", "::", "LVXL", ":", "LoadSize", "=", "16", ";", "break", ";", "}", "if", "(", "isLoadOfStoredAddress", "(", "LoadSize", ",", "Node", "->", "getOperand", "(", "0", ")", ",", "Node", "->", "getOperand", "(", "1", ")", ")", ")", "return", "NoopHazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "\"PPC hazards don't support scoreboard lookahead\"", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "0", "2", "\"Unknown instruction type!\"", "PPCII::PPC970_FXU", "PPCII::PPC970_LSU", "PPCII::PPC970_FPU", "PPCII::PPC970_VALU", "PPCII::PPC970_VPERM", "4", "PPCII::PPC970_CRU", "2", "PPCII::PPC970_BRU", "PPC::BCTRL_Darwin", "PPC::BCTRL_SVR4", "\"Unknown load!\"", "PPC::LBZ", "PPC::LBZU", "PPC::LBZX", "PPC::LBZ8", "PPC::LBZU8", "PPC::LBZX8", "PPC::LVEBX", "1", "PPC::LHA", "PPC::LHAU", "PPC::LHAX", "PPC::LHZ", "PPC::LHZU", "PPC::LHZX", "PPC::LVEHX", "PPC::LHBRX", "PPC::LHA8", "PPC::LHAU8", "PPC::LHAX8", "PPC::LHZ8", "PPC::LHZU8", "PPC::LHZX8", "2", "PPC::LFS", "PPC::LFSU", "PPC::LFSX", "PPC::LWZ", "PPC::LWZU", "PPC::LWZX", "PPC::LWA", "PPC::LWAX", "PPC::LVEWX", "PPC::LWBRX", "PPC::LWZ8", "PPC::LWZX8", "4", "PPC::LFD", "PPC::LFDU", "PPC::LFDX", "PPC::LD", "PPC::LDU", "PPC::LDX", "8", "PPC::LVX", "PPC::LVXL", "16", "0", "1" ]

PPCHazardRecognizers30

getHazardType

PowerPC

CPU

LLVM

16,574

500

1

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsVarArg", "=", "MF", ".", "getFunction", "(", ")", ".", "isVarArg", "(", ")", ";", "if", "(", "IsVarArg", ")", "for", "(", "unsigned", "I", "=", "MFI", "->", "getVarArgsFirstGPR", "(", ")", ";", "I", "<", "SystemZ", "::", "NumArgGPRs", ";", "++", "I", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "ArgGPRs", "[", "I", "]", ")", ";", "if", "(", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R6D", ")", ";", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R7D", ")", ";", "}", "if", "(", "HasFP", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "if", "(", "MFFrame", ".", "hasCalls", "(", ")", ")", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R14D", ")", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "TRI", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "CSRegs", "[", "I", "]", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "CSRegs", "[", "I", "]", ";", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "contains", "(", "Reg", ")", "&&", "SavedRegs", ".", "test", "(", "Reg", ")", ")", "{", "SavedRegs", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ::NumArgGPRs", "SystemZ::ArgGPRs", "SystemZ::R6D", "SystemZ::R7D", "SystemZ::R11D", "SystemZ::R14D", "0", "SystemZ::GR64BitRegClass", "SystemZ::R15D" ]

SystemZFrameLowering1

determineCalleeSaves

SystemZ

CPU

LLVM

16,575

258

1

[]

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

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

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

X86ATTInstPrinter12

printInst

X86

CPU

LLVM

16,576

37

1

[]

[ "<s>", "int", "c4x_R_constraint", "(", "rtx", "op", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "TARGET_C3X", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", ")", "return", "0", ";", "if", "(", "mode", "==", "HImode", "||", "mode", "==", "HFmode", ")", "return", "IS_UINT5_CONST", "(", "INTVAL", "(", "op1", ")", "+", "1", ")", ";", "return", "IS_UINT5_CONST", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "ARx", "+", "5-bit", "unsigned", "const", "*", "ARx", ",", "*", "+ARx", "(", "n", ")", "for", "n", "<", "32", "." ]

[ "c4x", "0", "0", "0", "1", "0", "1", "0", "0", "1", "0" ]

c4x1

c4x_R_constraint

c4x

DSP

GCC

16,577

147

1

[]

[ "<s>", "Register", "LC2200RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "LC2200Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "LC2200Subtarget", ">", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "Subtarget", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "LC2200", "::", "fp", ":", "LC2200", "::", "sp", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200", "LC2200", "LC2200::fp", "LC2200::sp" ]

LC2200RegisterInfo

getFrameRegister

LC2200

CPU

LLVM

16,578

54

1

[]

[ "<s>", "int", "ARMBaseInstrInfo", "::", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "*", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "-", "1", ";", "const", "MachineOperand", "&", "DefMO", "=", "DefMI", "->", "getOperand", "(", "DefIdx", ")", ";", "unsigned", "Reg", "=", "DefMO", ".", "getReg", "(", ")", ";", "const", "MCInstrDesc", "*", "DefMCID", "=", "&", "DefMI", "->", "getDesc", "(", ")", ";", "const", "MCInstrDesc", "*", "UseMCID", "=", "&", "UseMI", "->", "getDesc", "(", ")", ";", "unsigned", "DefAdj", "=", "0", ";", "if", "(", "DefMI", "->", "isBundle", "(", ")", ")", "{", "DefMI", "=", "getBundledDefMI", "(", "&", "getRegisterInfo", "(", ")", ",", "DefMI", ",", "Reg", ",", "DefIdx", ",", "DefAdj", ")", ";", "DefMCID", "=", "&", "DefMI", "->", "getDesc", "(", ")", ";", "}", "if", "(", "DefMI", "->", "isCopyLike", "(", ")", "||", "DefMI", "->", "isInsertSubreg", "(", ")", "||", "DefMI", "->", "isRegSequence", "(", ")", "||", "DefMI", "->", "isImplicitDef", "(", ")", ")", "{", "return", "1", ";", "}", "unsigned", "UseAdj", "=", "0", ";", "if", "(", "UseMI", "->", "isBundle", "(", ")", ")", "{", "unsigned", "NewUseIdx", ";", "const", "MachineInstr", "*", "NewUseMI", "=", "getBundledUseMI", "(", "&", "getRegisterInfo", "(", ")", ",", "UseMI", ",", "Reg", ",", "NewUseIdx", ",", "UseAdj", ")", ";", "if", "(", "!", "NewUseMI", ")", "return", "-", "1", ";", "UseMI", "=", "NewUseMI", ";", "UseIdx", "=", "NewUseIdx", ";", "UseMCID", "=", "&", "UseMI", "->", "getDesc", "(", ")", ";", "}", "if", "(", "Reg", "==", "ARM", "::", "CPSR", ")", "{", "if", "(", "DefMI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "FMSTAT", ")", "{", "return", "Subtarget", ".", "isLikeA9", "(", ")", "?", "1", ":", "20", ";", "}", "if", "(", "UseMI", "->", "isBranch", "(", ")", ")", "return", "0", ";", "unsigned", "Latency", "=", "getInstrLatency", "(", "ItinData", ",", "DefMI", ")", ";", "if", "(", "Latency", ">", "0", "&&", "Subtarget", ".", "isThumb2", "(", ")", ")", "{", "const", "MachineFunction", "*", "MF", "=", "DefMI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getFnAttributes", "(", ")", ".", "hasAttribute", "(", "Attributes", "::", "OptimizeForSize", ")", ")", "--", "Latency", ";", "}", "return", "Latency", ";", "}", "if", "(", "DefMO", ".", "isImplicit", "(", ")", "||", "UseMI", "->", "getOperand", "(", "UseIdx", ")", ".", "isImplicit", "(", ")", ")", "return", "-", "1", ";", "unsigned", "DefAlign", "=", "DefMI", "->", "hasOneMemOperand", "(", ")", "?", "(", "*", "DefMI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "unsigned", "UseAlign", "=", "UseMI", "->", "hasOneMemOperand", "(", ")", "?", "(", "*", "UseMI", "->", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ":", "0", ";", "int", "Latency", "=", "getOperandLatency", "(", "ItinData", ",", "*", "DefMCID", ",", "DefIdx", ",", "DefAlign", ",", "*", "UseMCID", ",", "UseIdx", ",", "UseAlign", ")", ";", "if", "(", "Latency", "<", "0", ")", "return", "Latency", ";", "int", "Adj", "=", "DefAdj", "+", "UseAdj", ";", "Adj", "+=", "adjustDefLatency", "(", "Subtarget", ",", "DefMI", ",", "DefMCID", ",", "DefAlign", ")", ";", "if", "(", "Adj", ">=", "0", "||", "(", "int", ")", "Latency", ">", "-", "Adj", ")", "{", "return", "Latency", "+", "Adj", ";", "}", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "and", "return", "the", "use", "operand", "latency", "of", "a", "given", "pair", "of", "def", "and", "use", "." ]

[ "ARM", "ARM", "1", "0", "1", "0", "1", "ARM::CPSR", "ARM::FMSTAT", "1", "20", "0", "0", "1", "0", "0", "0", "0" ]

ARMBaseInstrInfo101

getOperandLatency

ARM

CPU

LLVM

16,579

483

1

[]

[ "<s>", "BlackfinTargetLowering", "::", "ConstraintType", "BlackfinTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "!=", "1", ")", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'a'", ":", "case", "'d'", ":", "case", "'z'", ":", "case", "'D'", ":", "case", "'W'", ":", "case", "'e'", ":", "case", "'b'", ":", "case", "'v'", ":", "case", "'f'", ":", "case", "'c'", ":", "case", "'t'", ":", "case", "'u'", ":", "case", "'k'", ":", "case", "'x'", ":", "case", "'y'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'A'", ":", "case", "'B'", ":", "case", "'C'", ":", "case", "'Z'", ":", "case", "'Y'", ":", "return", "C_Register", ";", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "1", "0" ]

BlackfinISelLowering

getConstraintType

Blackfin

DSP

LLVM

16,580

127

1

[]

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

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

[ "X86" ]

X86FixupBWInsts1

getAnalysisUsage

X86

CPU

LLVM

16,581

27

1

[]

[ "<s>", "static", "bool", "ix86_legitimate_constant_p", "(", "machine_mode", ",", "rtx", "x", ")", "{", "if", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "darwin_local_data_pic", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOT", ":", "case", "UNSPEC_GOTOFF", ":", "case", "UNSPEC_PLTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "case", "UNSPEC_NTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "case", "UNSPEC_DTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "SYMBOL_REF_DLLIMPORT_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "MACHO_DYNAMIC_NO_PIC_P", ")", "return", "machopic_symbol_defined_p", "(", "x", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "GET_MODE", "(", "x", ")", "==", "TImode", "&&", "x", "!=", "CONST0_RTX", "(", "TImode", ")", "&&", "!", "TARGET_64BIT", ")", "return", "false", ";", "break", ";", "case", "CONST_VECTOR", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]

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

i3864

ix86_legitimate_constant_p

i386

CPU

GCC

16,582

304

1

[]

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

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

[ "AZPR" ]

DelaySlotFiller

runOnMachineFunction

AZPR

CPU

LLVM

16,583

53

1

[]

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

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

[ "PowerPC", "4", "0", "4", "0", "0x60000000" ]

PPCAsmBackend12

writeNopData

PowerPC

CPU

LLVM

16,584

55

1

[]

[ "<s>", "static", "uint16_t", "name", "(", "struct", "InternalInstruction", "*", "insn", ",", "OperandType", "type", ",", "\\", "uint8_t", "index", ",", "uint8_t", "*", "valid", ")", "{", "\\", "*", "valid", "=", "1", ";", "\\", "switch", "(", "type", ")", "{", "\\", "default", ":", "\\", "debug", "(", "\"Unhandled register type\"", ")", ";", "\\", "*", "valid", "=", "0", ";", "\\", "return", "0", ";", "\\", "case", "TYPE_Rv", ":", "\\", "return", "base", "+", "index", ";", "\\", "case", "TYPE_R8", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "*", "valid", "=", "0", ";", "\\", "if", "(", "insn", "->", "rexPrefix", "&&", "index", ">=", "4", "&&", "index", "<=", "7", ")", "{", "\\", "return", "prefix", "##", "_SPL", "+", "(", "index", "-", "4", ")", ";", "\\", "}", "else", "{", "\\", "return", "prefix", "##", "_AL", "+", "index", ";", "\\", "}", "\\", "case", "TYPE_R16", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_AX", "+", "index", ";", "\\", "case", "TYPE_R32", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_EAX", "+", "index", ";", "\\", "case", "TYPE_R64", ":", "\\", "index", "&=", "mask", ";", "\\", "if", "(", "index", ">", "0xf", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_RAX", "+", "index", ";", "\\", "case", "TYPE_ZMM", ":", "\\", "return", "prefix", "##", "_ZMM0", "+", "index", ";", "\\", "case", "TYPE_YMM", ":", "\\", "return", "prefix", "##", "_YMM0", "+", "index", ";", "\\", "case", "TYPE_XMM", ":", "\\", "return", "prefix", "##", "_XMM0", "+", "index", ";", "\\", "case", "TYPE_TMM", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_TMM0", "+", "index", ";", "\\", "case", "TYPE_VK", ":", "\\", "index", "&=", "0xf", ";", "\\", "if", "(", "index", ">", "7", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_K0", "+", "index", ";", "\\", "case", "TYPE_VK_PAIR", ":", "\\", "if", "(", "index", ">", "7", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_K0_K1", "+", "(", "index", "/", "2", ")", ";", "\\", "case", "TYPE_MM64", ":", "\\", "return", "prefix", "##", "_MM0", "+", "(", "index", "&", "0x7", ")", ";", "\\", "case", "TYPE_SEGMENTREG", ":", "\\", "if", "(", "(", "index", "&", "7", ")", ">", "5", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_ES", "+", "(", "index", "&", "7", ")", ";", "\\", "case", "TYPE_DEBUGREG", ":", "\\", "return", "prefix", "##", "_DR0", "+", "index", ";", "\\", "case", "TYPE_CONTROLREG", ":", "\\", "return", "prefix", "##", "_CR0", "+", "index", ";", "\\", "case", "TYPE_BNDR", ":", "\\", "if", "(", "index", ">", "3", ")", "\\", "*", "valid", "=", "0", ";", "\\", "return", "prefix", "##", "_BND0", "+", "index", ";", "\\", "case", "TYPE_MVSIBX", ":", "\\", "return", "prefix", "##", "_XMM0", "+", "index", ";", "\\", "case", "TYPE_MVSIBY", ":", "\\", "return", "prefix", "##", "_YMM0", "+", "index", ";", "\\", "case", "TYPE_MVSIBZ", ":", "\\", "return", "prefix", "##", "_ZMM0", "+", "index", ";", "\\", "}", "\\", "}", "</s>" ]

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

[ "X86", "1", "\"Unhandled register type\"", "0", "0", "0xf", "0", "4", "7", "4", "0xf", "0", "0xf", "0", "0xf", "0", "7", "0", "0xf", "7", "0", "7", "0", "2", "0x7", "7", "5", "0", "7", "3", "0" ]

X86Disassembler24

name

X86

CPU

LLVM

16,585

474

1

[]

[ "<s>", "static", "void", "h8300_insert_attributes", "(", "tree", "node", ",", "tree", "*", "attributes", ")", "{", "if", "(", "TREE_CODE", "(", "node", ")", "==", "FUNCTION_DECL", ")", "{", "if", "(", "pragma_interrupt", ")", "{", "pragma_interrupt", "=", "0", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"interrupt_handler\"", ")", ",", "NULL", ",", "*", "attributes", ")", ";", "}", "if", "(", "pragma_saveall", ")", "{", "pragma_saveall", "=", "0", ";", "*", "attributes", "=", "tree_cons", "(", "get_identifier", "(", "\"saveall\"", ")", ",", "NULL", ",", "*", "attributes", ")", ";", "}", "}", "}", "</s>" ]

[ "Generate", "an", "'interrupt_handler", "'", "attribute", "for", "decls", ".", "We", "convert", "all", "the", "pragmas", "to", "corresponding", "attributes", "." ]

[ "h8300", "0", "\"interrupt_handler\"", "0", "\"saveall\"" ]

h8300

h8300_insert_attributes

h8300

MPU

GCC

16,586

76

1

[]

[ "<s>", "DecodeStatus", "SparcDisassembler", "::", "getInstruction", "(", "MCInst", "&", "Instr", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "CStream", ")", "const", "{", "uint32_t", "Insn", ";", "bool", "isLittleEndian", "=", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", "->", "isLittleEndian", "(", ")", ";", "DecodeStatus", "Result", "=", "readInstruction32", "(", "Bytes", ",", "Address", ",", "Size", ",", "Insn", ",", "isLittleEndian", ")", ";", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "Sparc", "::", "FeatureV9", "]", ")", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableSparcV932", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "else", "{", "Result", "=", "decodeInstruction", "(", "DecoderTableSparcV832", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "}", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableSparc32", ",", "Instr", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "4", ";", "return", "Result", ";", "}", "return", "MCDisassembler", "::", "Fail", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "Sparc::FeatureV9", "Sparc", "Sparc", "Sparc", "4" ]

SparcDisassembler (2)1

getInstruction

Sparc

CPU

LLVM

16,587

178

1

[]

[ "<s>", "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected Kind in getPointerRegClass!\"", ")", ";", "case", "0", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "||", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "1", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "||", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "2", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "||", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREXRegClass", ";", "return", "&", "X86", "::", "GR32_NOREXRegClass", ";", "case", "3", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", "||", "Subtarget", ".", "isTargetNaCl64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOREX_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOREX_NOSPRegClass", ";", "case", "4", ":", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "||", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_64_Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}", "</s>" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "X86", "X86", "X86", "X86", "\"Unexpected Kind in getPointerRegClass!\"", "0", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "2", "X86::GR64_NOREXRegClass", "X86::GR32_NOREXRegClass", "3", "X86::GR64_NOREX_NOSPRegClass", "X86::GR32_NOREX_NOSPRegClass", "4", "X86", "X86::GR64_TCW64RegClass", "X86::GR64_TCRegClass", "X86::GR32RegClass", "X86::GR32_TCRegClass" ]

X86RegisterInfo87

getPointerRegClass

X86

CPU

LLVM

16,588

245

1

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "MipsTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "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", "(", "Subtarget", "->", "hasMSA", "(", ")", "&&", "type", "->", "isVectorTy", "(", ")", "&&", "cast", "<", "VectorType", ">", "(", "type", ")", "->", "getBitWidth", "(", ")", "==", "128", ")", "weight", "=", "CW_Register", ";", "else", "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", "128" ]

MipsISelLowering (2)1

getSingleConstraintMatchWeight

Mips

CPU

LLVM

16,589

214

1

[]

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

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

[ "AAP", "14" ]

AAPAsmBackend

getNumFixupKinds

AAP

MPU

LLVM

16,590

11

1

[]

[ "<s>", "int", "loongarch_class_max_nregs", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ")", "{", "int", "size", ";", "HARD_REG_SET", "left", ";", "size", "=", "0x8000", ";", "left", "=", "reg_class_contents", "[", "rclass", "]", ";", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FCC_REGS", "]", ")", ")", "{", "if", "(", "loongarch_hard_regno_mode_ok", "(", "FCC_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "4", ")", ";", "left", "&=", "~", "reg_class_contents", "[", "FCC_REGS", "]", ";", "}", "if", "(", "hard_reg_set_intersect_p", "(", "left", ",", "reg_class_contents", "[", "(", "int", ")", "FP_REGS", "]", ")", ")", "{", "if", "(", "loongarch_hard_regno_mode_ok", "(", "FP_REG_FIRST", ",", "mode", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_FPREG", ")", ";", "left", "&=", "~", "reg_class_contents", "[", "FP_REGS", "]", ";", "}", "if", "(", "!", "hard_reg_set_empty_p", "(", "left", ")", ")", "size", "=", "MIN", "(", "size", ",", "UNITS_PER_WORD", ")", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "size", "-", "1", ")", "/", "size", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", ",", "taking", "the", "maximum", "of", "the", "cases", "in", "loongarch_hard_regno_nregs", "." ]

[ "loongarch", "0x8000", "4", "1" ]

loongarch

loongarch_class_max_nregs

loongarch

CPU

GCC

16,591

146

1

[]

[ "<s>", "SDValue", "ARM64SelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "ConstantSDNode", "*", "V", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Src", ")", ";", "ConstantSDNode", "*", "SizeValue", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Size", ")", ";", "const", "char", "*", "bzeroEntry", "=", "(", "V", "&&", "V", "->", "isNullValue", "(", ")", ")", "?", "Subtarget", "->", "getBZeroEntry", "(", ")", ":", "nullptr", ";", "if", "(", "bzeroEntry", "&&", "(", "!", "SizeValue", "||", "SizeValue", "->", "getZExtValue", "(", ")", ">", "256", ")", ")", "{", "const", "ARM64TargetLowering", "&", "TLI", "=", "*", "static_cast", "<", "const", "ARM64TargetLowering", "*", ">", "(", "DAG", ".", "getTarget", "(", ")", ".", "getTargetLowering", "(", ")", ")", ";", "EVT", "IntPtr", "=", "TLI", ".", "getPointerTy", "(", ")", ";", "Type", "*", "IntPtrTy", "=", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "Chain", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "false", ",", "false", ",", "false", ",", "false", ",", "0", ",", "CallingConv", "::", "C", ",", "false", ",", "false", ",", "false", ",", "DAG", ".", "getExternalSymbol", "(", "bzeroEntry", ",", "IntPtr", ")", ",", "Args", ",", "DAG", ",", "dl", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "256", "ARM64", "ARM64", "0" ]

ARM64SelectionDAGInfo

EmitTargetCodeForMemset

ARM64

CPU

LLVM

16,592

277

1

[]

[ "<s>", "bool", "NVPTXFavorNonGenericAddrSpaces", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "DisableFavorNonGeneric", "||", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "B", ":", "F", ")", "{", "for", "(", "Instruction", "&", "I", ":", "B", ")", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "Changed", "|=", "optimizeMemoryInstruction", "(", "&", "I", ",", "0", ")", ";", "}", "else", "if", "(", "isa", "<", "StoreInst", ">", "(", "I", ")", ")", "{", "Changed", "|=", "optimizeMemoryInstruction", "(", "&", "I", ",", "1", ")", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

NVPTXFavorNonGenericAddrSpaces8

runOnFunction

NVPTX

GPU

LLVM

16,593

96

1

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", ")", "return", "X86II", "::", "MO_DLLIMPORT", ";", "bool", "isDecl", "=", "GV", "->", "isDeclarationForLinker", "(", ")", ";", "if", "(", "isPICStyleRIPRel", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "GV", "->", "hasDefaultVisibility", "(", ")", "&&", "(", "isDecl", "||", "GV", "->", "isWeakForLinker", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "else", "if", "(", "!", "isTargetWin64", "(", ")", ")", "{", "assert", "(", "isTargetELF", "(", ")", "&&", "\"Unknown rip-relative target\"", ")", ";", "if", "(", "!", "GV", "->", "hasLocalLinkage", "(", ")", "&&", "GV", "->", "hasDefaultVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "if", "(", "isPICStyleGOT", "(", ")", ")", "{", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", "||", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_GOTOFF", ";", "return", "X86II", "::", "MO_GOT", ";", "}", "if", "(", "isPICStyleStubPIC", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY_PIC_BASE", ";", "if", "(", "isDecl", "||", "GV", "->", "hasCommonLinkage", "(", ")", ")", "{", "return", "X86II", "::", "MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", ";", "}", "return", "X86II", "::", "MO_PIC_BASE_OFFSET", ";", "}", "if", "(", "isPICStyleStubNoDynamic", "(", ")", ")", "{", "if", "(", "!", "isDecl", "&&", "!", "GV", "->", "isWeakForLinker", "(", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "!", "GV", "->", "hasHiddenVisibility", "(", ")", ")", "return", "X86II", "::", "MO_DARWIN_NONLAZY", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_DLLIMPORT", "X86II::MO_NO_FLAG", "X86II::MO_GOTPCREL", "\"Unknown rip-relative target\"", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_GOTOFF", "X86II::MO_GOT", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_DARWIN_NONLAZY_PIC_BASE", "X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE", "X86II::MO_PIC_BASE_OFFSET", "X86II::MO_NO_FLAG", "X86II::MO_DARWIN_NONLAZY", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

X86Subtarget (2)1

ClassifyGlobalReference

X86

CPU

LLVM

16,594

283

1

[]

[ "<s>", "void", "SystemZPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZShortenInstPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createSystemZElimComparePass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createSystemZLongBranchPass", "(", "getSystemZTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "PostMachineSchedulerID", ")", ";", "}", "</s>" ]

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

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

SystemZTargetMachine18

addPreEmitPass

SystemZ

CPU

LLVM

16,595

74

1

[]

[ "<s>", "MachineInstr", "*", "LanaiInstrInfo", "::", "optimizeSelect", "(", "MachineInstr", "&", "MI", ",", "SmallPtrSetImpl", "<", "MachineInstr", "*", ">", "&", "SeenMIs", ",", "bool", ")", "const", "{", "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "Lanai", "::", "SELECT", "&&", "\"unknown select instruction\"", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineInstr", "*", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "bool", "Invert", "=", "!", "DefMI", ";", "if", "(", "!", "DefMI", ")", "DefMI", "=", "canFoldIntoSelect", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "MRI", ")", ";", "if", "(", "!", "DefMI", ")", "return", "nullptr", ";", "MachineOperand", "FalseReg", "=", "MI", ".", "getOperand", "(", "Invert", "?", "1", ":", "2", ")", ";", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "PreviousClass", "=", "MRI", ".", "getRegClass", "(", "FalseReg", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "PreviousClass", ")", ")", "return", "nullptr", ";", "MachineInstrBuilder", "NewMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "DefMI", "->", "getDesc", "(", ")", ",", "DestReg", ")", ";", "const", "MCInstrDesc", "&", "DefDesc", "=", "DefMI", "->", "getDesc", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "DefDesc", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", "&&", "!", "DefDesc", ".", "OpInfo", "[", "i", "]", ".", "isPredicate", "(", ")", ";", "++", "i", ")", "NewMI", ".", "add", "(", "DefMI", "->", "getOperand", "(", "i", ")", ")", ";", "unsigned", "CondCode", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Invert", ")", "NewMI", ".", "addImm", "(", "getOppositeCondition", "(", "LPCC", "::", "CondCode", "(", "CondCode", ")", ")", ")", ";", "else", "NewMI", ".", "addImm", "(", "CondCode", ")", ";", "NewMI", ".", "copyImplicitOps", "(", "MI", ")", ";", "FalseReg", ".", "setImplicit", "(", ")", ";", "NewMI", ".", "add", "(", "FalseReg", ")", ";", "NewMI", "->", "tieOperands", "(", "0", ",", "NewMI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "SeenMIs", ".", "insert", "(", "NewMI", ")", ";", "SeenMIs", ".", "erase", "(", "DefMI", ")", ";", "if", "(", "DefMI", "->", "getParent", "(", ")", "!=", "MI", ".", "getParent", "(", ")", ")", "NewMI", "->", "clearKillInfo", "(", ")", ";", "DefMI", "->", "eraseFromParent", "(", ")", ";", "return", "NewMI", ";", "}", "</s>" ]

[ "Given", "a", "select", "instruction", "that", "was", "understood", "by", "analyzeSelect", "and", "returned", "Optimizable", "=", "true", ",", "attempt", "to", "optimize", "MI", "by", "merging", "it", "with", "one", "of", "its", "operands", "." ]

[ "Lanai", "Lanai", "Lanai::SELECT", "\"unknown select instruction\"", "1", "2", "1", "2", "0", "1", "3", "0", "1" ]

LanaiInstrInfo (2)

optimizeSelect

Lanai

CPU

LLVM

16,596

377

1

[]

[ "<s>", "static", "bool", "mips_cfg_in_reorg", "(", "void", ")", "{", "return", "(", "mips_r10k_cache_barrier", "!=", "R10K_CACHE_BARRIER_NONE", "||", "TARGET_RELAX_PIC_CALLS", ")", ";", "}", "</s>" ]

[ "Return", "whether", "CFG", "is", "used", "in", "mips_reorg", "." ]

[ "mips" ]

mips

mips_cfg_in_reorg

mips

CPU

GCC

16,597

17

1

[]

[ "<s>", "bool", "WebAssemblyOptimizeLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "LiveIntervals", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"OptimizeLiveIntervals expects liveness\"", ")", ";", "SmallVector", "<", "LiveInterval", "*", ",", "4", ">", "SplitLIs", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "i", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "LIS", ".", "splitSeparateComponents", "(", "LIS", ".", "getInterval", "(", "Reg", ")", ",", "SplitLIs", ")", ";", "SplitLIs", ".", "clear", "(", ")", ";", "}", "for", "(", "auto", "MII", "=", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "MIE", "=", "MF", ".", "begin", "(", ")", "->", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "MI", "->", "isImplicitDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "LIS", ".", "removeVRegDefAt", "(", "LI", ",", "LIS", ".", "getInstructionIndex", "(", "*", "MI", ")", ".", "getRegSlot", "(", ")", ")", ";", "LIS", ".", "RemoveMachineInstrFromMaps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "\"OptimizeLiveIntervals expects liveness\"", "4", "0", "0", "0" ]

WebAssemblyOptimizeLiveIntervals14

runOnMachineFunction

WebAssembly

Virtual ISA

LLVM

16,598

261

1

[]

[ "<s>", "static", "bool", "aarch64_validate_mcpu", "(", "const", "char", "*", "str", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ")", "{", "enum", "aarch64_parse_opt_result", "parse_res", "=", "aarch64_parse_cpu", "(", "str", ",", "res", ",", "isa_flags", ")", ";", "if", "(", "parse_res", "==", "AARCH64_PARSE_OK", ")", "return", "true", ";", "switch", "(", "parse_res", ")", "{", "case", "AARCH64_PARSE_MISSING_ARG", ":", "error", "(", "\"missing cpu name in %<-mcpu=%s%>\"", ",", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "error", "(", "\"unknown value %qs for -mcpu\"", ",", "str", ")", ";", "aarch64_print_hint_for_core", "(", "str", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_FEATURE", ":", "error", "(", "\"invalid feature modifier in %<-mcpu=%s%>\"", ",", "str", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Validate", "a", "command-line", "-mcpu", "option", ".", "Parse", "the", "cpu", "and", "extensions", "(", "if", "any", ")", "specified", "in", "STR", "and", "throw", "errors", "if", "appropriate", ".", "Put", "the", "results", "if", "they", "are", "valid", "in", "RES", "and", "ISA_FLAGS", ".", "Return", "whether", "the", "option", "is", "valid", "." ]

[ "aarch64", "\"missing cpu name in %<-mcpu=%s%>\"", "\"unknown value %qs for -mcpu\"", "\"invalid feature modifier in %<-mcpu=%s%>\"" ]

aarch644

aarch64_validate_mcpu

aarch64

CPU

GCC

16,599

101

1

[]