Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "void", "mmix_file_end", "(", "void", ")", "{", "data_section", "(", ")", ";", "}", "</s>" ]

[ "TARGET_ASM_FILE_END", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "void", "force_into", "(", "rtx", "value", ",", "rtx", "target", ")", "{", "value", "=", "force_operand", "(", "value", ",", "target", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "value", ",", "target", ")", ")", "emit_insn", "(", "gen_move_insn", "(", "target", ",", "value", ")", ")", ";", "}", "</s>" ]

[ "Like", "force_operand", ",", "but", "guarantees", "that", "VALUE", "ends", "up", "in", "TARGET", "." ]

[ "sh" ]

[]

[ "<s>", "inline", "static", "bool", "isMemIntrinsic", "(", "const", "std", "::", "string", "&", "Name", ")", "{", "if", "(", "Name", ".", "compare", "(", "\"@memcpy\"", ")", "==", "0", "||", "Name", ".", "compare", "(", "\"@memset\"", ")", "==", "0", "||", "Name", ".", "compare", "(", "\"@memmove\"", ")", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Test", "if", "this", "node", "is", "a", "memory", "intrinsic", "(", "with", "valid", "pointer", "information", ")", "." ]

[ "PIC16", "\"@memcpy\"", "0", "\"@memset\"", "0", "\"@memmove\"", "0" ]

[]

[ "<s>", "unsigned", "M88kInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "M88k", "::", "LDrib", ":", "case", "M88k", "::", "LDrih", ":", "case", "M88k", "::", "LDriw", ":", "case", "M88k", "::", "LDrid", ":", "case", "M88k", "::", "LDrrsb", ":", "case", "M88k", "::", "LDrrsbu", ":", "case", "M88k", "::", "LDrrsd", ":", "case", "M88k", "::", "LDrrsdu", ":", "case", "M88k", "::", "LDrrsh", ":", "case", "M88k", "::", "LDrrshu", ":", "case", "M88k", "::", "LDrrsw", ":", "case", "M88k", "::", "LDrrswu", ":", "case", "M88k", "::", "LDrrub", ":", "case", "M88k", "::", "LDrrubu", ":", "case", "M88k", "::", "LDrrud", ":", "case", "M88k", "::", "LDrrudu", ":", "case", "M88k", "::", "LDrruh", ":", "case", "M88k", "::", "LDrruhu", ":", "case", "M88k", "::", "LDrruw", ":", "case", "M88k", "::", "LDrruwu", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "M88k", "M88k", "M88k::LDrib", "M88k::LDrih", "M88k::LDriw", "M88k::LDrid", "M88k::LDrrsb", "M88k::LDrrsbu", "M88k::LDrrsd", "M88k::LDrrsdu", "M88k::LDrrsh", "M88k::LDrrshu", "M88k::LDrrsw", "M88k::LDrrswu", "M88k::LDrrub", "M88k::LDrrubu", "M88k::LDrrud", "M88k::LDrrudu", "M88k::LDrruh", "M88k::LDrruhu", "M88k::LDrruw", "M88k::LDrruwu", "1", "1", "0", "0" ]

[]

[ "<s>", "static", "int", "alpha_elf_reloc_rw_mask", "(", "void", ")", "{", "return", "flag_pic", "?", "3", ":", "2", ";", "}", "</s>" ]

[ "Since", "we", "do", "n't", "have", "a", ".dynbss", "section", ",", "we", "should", "not", "allow", "global", "relocations", "in", "the", ".rodata", "section", "." ]

[ "alpha", "3", "2" ]

[]

[ "<s>", "extern", "rtx", "s390_build_signbit_mask", "(", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "TFmode", "&&", "TARGET_VXE", ")", "{", "wide_int", "mask_val", "=", "wi", "::", "set_bit_in_zero", "(", "127", ",", "128", ")", ";", "rtx", "mask", "=", "immed_wide_int_const", "(", "mask_val", ",", "TImode", ")", ";", "return", "gen_lowpart", "(", "TFmode", ",", "mask", ")", ";", "}", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "int", "inner_bitsize", "=", "GET_MODE_BITSIZE", "(", "inner_mode", ")", ";", "wide_int", "mask_val", "=", "wi", "::", "set_bit_in_zero", "(", "inner_bitsize", "-", "1", ",", "inner_bitsize", ")", ";", "machine_mode", "int_mode", "=", "related_int_vector_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "rtx", "mask", "=", "immed_wide_int_const", "(", "mask_val", ",", "GET_MODE_INNER", "(", "int_mode", ")", ")", ";", "mask", "=", "gen_lowpart", "(", "inner_mode", ",", "mask", ")", ";", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtvec", "v", "=", "rtvec_alloc", "(", "nunits", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nunits", ";", "i", "++", ")", "RTVEC_ELT", "(", "v", ",", "i", ")", "=", "mask", ";", "return", "gen_rtx_CONST_VECTOR", "(", "mode", ",", "v", ")", ";", "}", "</s>" ]

[ "Emit", "a", "vector", "constant", "that", "contains", "1s", "in", "each", "element", "'s", "sign", "bit", "position", "and", "0s", "in", "other", "positions", ".", "MODE", "is", "the", "desired", "constant", "'s", "mode", "." ]

[ "s390", "127", "128", "1", "0" ]

[]

[ "<s>", "bool", "AArch64SIMDInstrOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "ST", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "AArch64InstrInfo", "*", "AAII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "AAII", ")", "return", "false", ";", "SchedModel", ".", "init", "(", "&", "ST", ")", ";", "if", "(", "!", "SchedModel", ".", "hasInstrSchedModel", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "OptimizationKind", ":", "{", "VectorElem", ",", "Interleave", "}", ")", "{", "if", "(", "!", "shouldExitEarly", "(", "&", "MF", ",", "OptimizationKind", ")", ")", "{", "SmallVector", "<", "MachineInstr", "*", ",", "8", ">", "RemoveMIs", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "bool", "InstRewrite", ";", "if", "(", "OptimizationKind", "==", "VectorElem", ")", "InstRewrite", "=", "optimizeVectElement", "(", "MI", ")", ";", "else", "InstRewrite", "=", "optimizeLdStInterleave", "(", "MI", ")", ";", "if", "(", "InstRewrite", ")", "{", "RemoveMIs", ".", "push_back", "(", "&", "MI", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "RemoveMIs", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "8" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "getPostIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDNode", "*", "Op", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LSBaseSDNode", "*", "LSN", "=", "dyn_cast", "<", "LSBaseSDNode", ">", "(", "N", ")", ";", "if", "(", "!", "LSN", ")", "return", "false", ";", "EVT", "VT", "=", "LSN", "->", "getMemoryVT", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "bool", "IsLegalType", "=", "VT", "==", "MVT", "::", "i8", "||", "VT", "==", "MVT", "::", "i16", "||", "VT", "==", "MVT", "::", "i32", "||", "VT", "==", "MVT", "::", "i64", "||", "Subtarget", ".", "isHVXVectorType", "(", "VT", ".", "getSimpleVT", "(", ")", ")", ";", "if", "(", "!", "IsLegalType", ")", "return", "false", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", ")", "return", "false", ";", "Base", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "Offset", "=", "Op", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", ")", "return", "false", ";", "AM", "=", "ISD", "::", "POST_INC", ";", "int32_t", "V", "=", "cast", "<", "ConstantSDNode", ">", "(", "Offset", ".", "getNode", "(", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "Subtarget", ".", "getInstrInfo", "(", ")", "->", "isValidAutoIncImm", "(", "VT", ",", "V", ")", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "this", "node", "can", "be", "combined", "with", "a", "load", "/", "store", "to", "form", "a", "post-indexed", "load", "/", "store", "." ]

[ "Hexagon", "Hexagon", "ISD::MemIndexedMode", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::i64", "ISD::ADD", "0", "1", "ISD::POST_INC" ]

[]

[ "<s>", "void", "GCNScheduleDAGMILive", "::", "schedule", "(", ")", "{", "const", "SIRegisterInfo", "*", "SRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "TRI", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Unsched", ";", "Unsched", ".", "reserve", "(", "NumRegionInstrs", ")", ";", "for", "(", "auto", "&", "I", ":", "*", "this", ")", "Unsched", ".", "push_back", "(", "&", "I", ")", ";", "ScheduleDAGMILive", "::", "schedule", "(", ")", ";", "GCNMaxOccupancySchedStrategy", "&", "S", "=", "(", "GCNMaxOccupancySchedStrategy", "&", ")", "*", "SchedImpl", ";", "std", "::", "vector", "<", "unsigned", ">", "UnschedPressure", "=", "getRegPressure", "(", ")", ".", "MaxSetPressure", ";", "unsigned", "MaxSGPRs", "=", "std", "::", "max", "(", "getTopRPTracker", "(", ")", ".", "getPressure", "(", ")", ".", "MaxSetPressure", "[", "SRI", "->", "getSGPRPressureSet", "(", ")", "]", ",", "getBotRPTracker", "(", ")", ".", "getPressure", "(", ")", ".", "MaxSetPressure", "[", "SRI", "->", "getSGPRPressureSet", "(", ")", "]", ")", ";", "unsigned", "MaxVGPRs", "=", "std", "::", "max", "(", "getTopRPTracker", "(", ")", ".", "getPressure", "(", ")", ".", "MaxSetPressure", "[", "SRI", "->", "getVGPRPressureSet", "(", ")", "]", ",", "getBotRPTracker", "(", ")", ".", "getPressure", "(", ")", ".", "MaxSetPressure", "[", "SRI", "->", "getVGPRPressureSet", "(", ")", "]", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Pressure after scheduling:\\nSGPR = \"", "<<", "MaxSGPRs", "<<", "\"\\nVGPR = \"", "<<", "MaxVGPRs", "<<", "'\\n'", ")", ";", "if", "(", "MaxSGPRs", "<=", "S", ".", "SGPRCriticalLimit", "&&", "MaxVGPRs", "<=", "S", ".", "VGPRCriticalLimit", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Pressure in desired limits, done.\\n\"", ")", ";", "return", ";", "}", "unsigned", "WavesAfter", "=", "getMaxWaves", "(", "MaxSGPRs", ",", "MaxVGPRs", ",", "MF", ")", ";", "unsigned", "WavesUnsched", "=", "getMaxWaves", "(", "UnschedPressure", "[", "SRI", "->", "getSGPRPressureSet", "(", ")", "]", ",", "UnschedPressure", "[", "SRI", "->", "getVGPRPressureSet", "(", ")", "]", ",", "MF", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Occupancy before scheduling: \"", "<<", "WavesUnsched", "<<", "\", after \"", "<<", "WavesAfter", "<<", "\".\\n\"", ")", ";", "if", "(", "WavesAfter", ">=", "WavesUnsched", ")", "return", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Attempting to revert scheduling.\\n\"", ")", ";", "RegionEnd", "=", "RegionBegin", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Unsched", ")", "{", "if", "(", "MI", "->", "getIterator", "(", ")", "!=", "RegionEnd", ")", "{", "BB", "->", "remove", "(", "MI", ")", ";", "BB", "->", "insert", "(", "RegionEnd", ",", "MI", ")", ";", "if", "(", "LIS", ")", "{", "LIS", "->", "handleMove", "(", "*", "MI", ",", "true", ")", ";", "RegisterOperands", "RegOpers", ";", "RegOpers", ".", "collect", "(", "*", "MI", ",", "*", "TRI", ",", "MRI", ",", "ShouldTrackLaneMasks", ",", "false", ")", ";", "if", "(", "ShouldTrackLaneMasks", ")", "{", "SlotIndex", "SlotIdx", "=", "LIS", "->", "getInstructionIndex", "(", "*", "MI", ")", ".", "getRegSlot", "(", ")", ";", "RegOpers", ".", "adjustLaneLiveness", "(", "*", "LIS", ",", "MRI", ",", "SlotIdx", ",", "MI", ")", ";", "}", "else", "{", "RegOpers", ".", "detectDeadDefs", "(", "*", "MI", ",", "*", "LIS", ")", ";", "}", "}", "}", "RegionEnd", "=", "MI", "->", "getIterator", "(", ")", ";", "++", "RegionEnd", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling \"", "<<", "*", "MI", ")", ";", "}", "RegionBegin", "=", "Unsched", ".", "front", "(", ")", "->", "getIterator", "(", ")", ";", "placeDebugValues", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "\"Pressure after scheduling:\\nSGPR = \"", "\"\\nVGPR = \"", "\"Pressure in desired limits, done.\\n\"", "\"Occupancy before scheduling: \"", "\", after \"", "\".\\n\"", "\"Attempting to revert scheduling.\\n\"", "\"Scheduling \"" ]

[]

[ "<s>", "static", "const", "struct", "tilegx_multiply_insn_seq", "*", "tilegx_find_multiply_insn_seq_for_constant", "(", "long", "long", "multiplier", ")", "{", "return", "(", "(", "const", "struct", "tilegx_multiply_insn_seq", "*", ")", "bsearch", "(", "&", "multiplier", ",", "tilegx_multiply_insn_seq_table", ",", "tilegx_multiply_insn_seq_table_size", ",", "sizeof", "tilegx_multiply_insn_seq_table", "[", "0", "]", ",", "tilegx_compare_multipliers", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "tilegx_multiply_insn_seq", "for", "multiplier", ",", "or", "NULL", "if", "none", "exists", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SELECT_CC", ":", "{", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "3", ")", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "if", "(", "Tmp", "==", "1", ")", "return", "1", ";", "unsigned", "Tmp2", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "4", ")", ",", "DemandedElts", ",", "Depth", "+", "1", ")", ";", "return", "std", "::", "min", "(", "Tmp", ",", "Tmp2", ")", ";", "}", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "case", "RISCVISD", "::", "DIVW", ":", "case", "RISCVISD", "::", "DIVUW", ":", "case", "RISCVISD", "::", "REMUW", ":", "case", "RISCVISD", "::", "ROLW", ":", "case", "RISCVISD", "::", "RORW", ":", "case", "RISCVISD", "::", "GREVW", ":", "case", "RISCVISD", "::", "GORCW", ":", "case", "RISCVISD", "::", "FSLW", ":", "case", "RISCVISD", "::", "FSRW", ":", "case", "RISCVISD", "::", "SHFLW", ":", "case", "RISCVISD", "::", "UNSHFLW", ":", "case", "RISCVISD", "::", "BCOMPRESSW", ":", "case", "RISCVISD", "::", "BDECOMPRESSW", ":", "case", "RISCVISD", "::", "FCVT_W_RTZ_RV64", ":", "case", "RISCVISD", "::", "FCVT_WU_RTZ_RV64", ":", "case", "RISCVISD", "::", "STRICT_FCVT_W_RTZ_RV64", ":", "case", "RISCVISD", "::", "STRICT_FCVT_WU_RTZ_RV64", ":", "return", "33", ";", "case", "RISCVISD", "::", "SHFL", ":", "case", "RISCVISD", "::", "UNSHFL", ":", "{", "if", "(", "Op", ".", "getValueType", "(", ")", "==", "MVT", "::", "i64", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "&&", "(", "Op", ".", "getConstantOperandVal", "(", "1", ")", "&", "0x10", ")", "==", "0", ")", "{", "unsigned", "Tmp", "=", "DAG", ".", "ComputeNumSignBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "if", "(", "Tmp", ">", "32", ")", "return", "33", ";", "}", "break", ";", "}", "case", "RISCVISD", "::", "VMV_X_S", ":", "if", "(", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", ">", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "1", ";", "return", "Subtarget", ".", "getXLen", "(", ")", "-", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", "+", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "RISCV", "RISCV", "RISCVISD::SELECT_CC", "3", "1", "1", "1", "4", "1", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "RISCVISD::DIVW", "RISCVISD::DIVUW", "RISCVISD::REMUW", "RISCVISD::ROLW", "RISCVISD::RORW", "RISCVISD::GREVW", "RISCVISD::GORCW", "RISCVISD::FSLW", "RISCVISD::FSRW", "RISCVISD::SHFLW", "RISCVISD::UNSHFLW", "RISCVISD::BCOMPRESSW", "RISCVISD::BDECOMPRESSW", "RISCVISD::FCVT_W_RTZ_RV64", "RISCVISD::FCVT_WU_RTZ_RV64", "RISCVISD::STRICT_FCVT_W_RTZ_RV64", "RISCVISD::STRICT_FCVT_WU_RTZ_RV64", "33", "RISCVISD::SHFL", "RISCVISD::UNSHFL", "MVT::i64", "1", "1", "0x10", "0", "0", "1", "32", "33", "RISCVISD::VMV_X_S", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "int", "move_dest_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "SUBREG", ":", "if", "(", "GET_CODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "MEM", ")", "return", "address_operand", "(", "XEXP", "(", "SUBREG_REG", "(", "op", ")", ",", "0", ")", ",", "mode", ")", ";", "else", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "MEM", ":", "return", "address_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "an", "acceptable", "argument", "for", "a", "move", "destination", "." ]

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

[]

[ "<s>", "inline", "void", "classify_registers", "(", "const_tree", ",", "HOST_WIDE_INT", "bitpos", ",", "bool", "fp", ",", "classify_data_t", "*", "data", ")", "{", "if", "(", "fp", ")", "{", "data", "->", "fp_regs", "=", "true", ";", "if", "(", "bitpos", "<", "BITS_PER_WORD", ")", "data", "->", "fp_regs_in_first_word", "=", "true", ";", "}", "else", "data", "->", "int_regs", "=", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_slotno", ".", "Classify", "the", "field", "." ]

[ "sparc" ]

[]

[ "<s>", "unsigned", "int", "pure_scalable_type_info", "::", "num_pr", "(", ")", "const", "{", "unsigned", "int", "res", "=", "0", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "pieces", ".", "length", "(", ")", ";", "++", "i", ")", "res", "+=", "pieces", "[", "i", "]", ".", "num_pr", ";", "return", "res", ";", "}", "</s>" ]

[ "Return", "the", "total", "number", "of", "predicate", "registers", "required", "by", "the", "PST", "." ]

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

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ",", "uint64_t", "&", "Target", ")", "const", "override", "{", "unsigned", "LblOperand", "=", "Inst", ".", "getOpcode", "(", ")", "==", "AArch64", "::", "Bcc", "?", "1", ":", "0", ";", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "LblOperand", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "false", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "LblOperand", ")", ".", "getImm", "(", ")", ";", "Target", "=", "Addr", "+", "Imm", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "AArch64", "AArch64::Bcc", "1", "0" ]

[]

[ "<s>", "int", "AlphaRegisterInfo", "::", "getDwarfRegNum", "(", "unsigned", "RegNum", ",", "bool", "isEH", ")", "const", "{", "assert", "(", "0", "&&", "\"What is the dwarf register number\"", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Map", "a", "target", "register", "to", "an", "equivalent", "dwarf", "register", "number", "." ]

[ "Alpha", "Alpha", "0", "\"What is the dwarf register number\"", "1" ]

[]

[ "<s>", "bool", "HexagonRDFOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "RDFLimit", ".", "getPosition", "(", ")", ")", "{", "if", "(", "RDFCount", ">=", "RDFLimit", ")", "return", "false", ";", "RDFCount", "++", ";", "}", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "const", "auto", "&", "HII", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "\"\\n\"", ",", "nullptr", ")", ";", "HexagonRegisterAliasInfo", "HAI", "(", "HRI", ")", ";", "TargetOperandInfo", "TOI", "(", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "HII", ",", "HRI", ",", "*", "MDT", ",", "MDF", ",", "HAI", ",", "TOI", ")", ";", "G", ".", "build", "(", "BuildOptions", "::", "KeepDeadPhis", ")", ";", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "\"Starting copy propagation on: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'\\n'", ";", "HexagonCP", "CP", "(", "G", ")", ";", "CP", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "=", "CP", ".", "run", "(", ")", ";", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "\"Starting dead code elimination on: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'\\n'", ";", "HexagonDCE", "DCE", "(", "G", ",", "*", "MRI", ")", ";", "DCE", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "|=", "DCE", ".", "run", "(", ")", ";", "if", "(", "Changed", ")", "{", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "\"Starting liveness recomputation on: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "Liveness", "LV", "(", "*", "MRI", ",", "G", ")", ";", "LV", ".", "trace", "(", "RDFDump", ")", ";", "LV", ".", "computeLiveIns", "(", ")", ";", "LV", ".", "resetLiveIns", "(", ")", ";", "LV", ".", "resetKills", "(", ")", ";", "}", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "\"\\n\"", ",", "nullptr", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Before \"", "\"\\n\"", "Hexagon", "\"Starting copy propagation on: \"", "Hexagon", "\"Starting dead code elimination on: \"", "Hexagon", "\"Starting liveness recomputation on: \"", "\"After \"", "\"\\n\"" ]

[]

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

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

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

[]

[ "<s>", "static", "bool", "mep_expand_setcc_1", "(", "enum", "rtx_code", "code", ",", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "rtx", "tmp", ";", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GTU", ":", "tmp", "=", "op1", ",", "op1", "=", "op2", ",", "op2", "=", "tmp", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "case", "LT", ":", "case", "LTU", ":", "op1", "=", "force_reg", "(", "SImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_fmt_ee", "(", "code", ",", "SImode", ",", "op1", ",", "op2", ")", ")", ")", ";", "return", "true", ";", "case", "EQ", ":", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "const1_rtx", ")", ";", "return", "true", ";", "case", "NE", ":", "if", "(", "optimize_size", "&&", "op2", "!=", "const0_rtx", ")", "return", "false", ";", "if", "(", "op2", "!=", "const0_rtx", ")", "op1", "=", "expand_binop", "(", "SImode", ",", "sub_optab", ",", "op1", ",", "op2", ",", "NULL", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "op2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "mep_expand_setcc_1", "(", "LTU", ",", "op2", ",", "op1", ",", "const1_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_XOR", "(", "SImode", ",", "op2", ",", "const1_rtx", ")", ")", ")", ";", "return", "true", ";", "case", "LE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "0x7ffffff", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "+", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "LT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "LEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "-", "1", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "+", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "LTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GE", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "op2", ")", "==", "trunc_int_for_mode", "(", "0x80000000", ",", "SImode", ")", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "INTVAL", "(", "op2", ")", "-", "1", ")", ";", "return", "mep_expand_setcc_1", "(", "GT", ",", "dest", ",", "op1", ",", "op2", ")", ";", "case", "GEU", ":", "if", "(", "GET_CODE", "(", "op2", ")", "!=", "CONST_INT", "||", "op2", "==", "const0_rtx", ")", "return", "false", ";", "op2", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", "-", "1", ",", "SImode", ")", ")", ";", "return", "mep_expand_setcc_1", "(", "GTU", ",", "dest", ",", "op1", ",", "op2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "setcc", "instruction", "in", "its", "entirity", "." ]

[ "mep", "1", "1", "0x7ffffff", "1", "1", "1", "0x80000000", "1", "1" ]

[]

[ "<s>", "static", "void", "load_lr_save", "(", "int", "regno", ",", "rtx", "frame_reg_rtx", ",", "int", "offset", ")", "{", "rtx", "mem", "=", "gen_frame_mem_offset", "(", "Pmode", ",", "frame_reg_rtx", ",", "offset", ")", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "emit_move_insn", "(", "reg", ",", "mem", ")", ";", "}", "</s>" ]

[ "Like", "cr", ",", "the", "move", "to", "lr", "instruction", "can", "be", "scheduled", "after", "the", "stack", "deallocation", ",", "but", "unlike", "cr", ",", "its", "stack", "frame", "save", "is", "still", "valid", ".", "So", "we", "only", "need", "to", "emit", "the", "cfa_restore", "on", "the", "correct", "instruction", "." ]

[ "powerpcspe" ]

[]

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

[ "Expand", "a", "vector", "interleave", "operation", "." ]

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

[]

[ "<s>", "rtx", "aarch64_expand_builtin", "(", "tree", "exp", ",", "rtx", "target", ",", "rtx", "subtarget", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "0", ")", ";", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "int", "icode", ";", "rtx", "pat", ",", "op0", ";", "tree", "arg0", ";", "switch", "(", "fcode", ")", "{", "case", "AARCH64_BUILTIN_GET_FPCR", ":", "case", "AARCH64_BUILTIN_SET_FPCR", ":", "case", "AARCH64_BUILTIN_GET_FPSR", ":", "case", "AARCH64_BUILTIN_SET_FPSR", ":", "if", "(", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPCR", ")", "||", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPSR", ")", ")", "{", "icode", "=", "(", "fcode", "==", "AARCH64_BUILTIN_GET_FPSR", ")", "?", "CODE_FOR_get_fpsr", ":", "CODE_FOR_get_fpcr", ";", "target", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ")", ";", "}", "else", "{", "target", "=", "NULL_RTX", ";", "icode", "=", "(", "fcode", "==", "AARCH64_BUILTIN_SET_FPSR", ")", "?", "CODE_FOR_set_fpsr", ":", "CODE_FOR_set_fpcr", ";", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "op0", "=", "force_reg", "(", "SImode", ",", "expand_normal", "(", "arg0", ")", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ")", ";", "}", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "if", "(", "fcode", ">=", "AARCH64_SIMD_BUILTIN_BASE", "&&", "fcode", "<=", "AARCH64_SIMD_BUILTIN_MAX", ")", "return", "aarch64_simd_expand_builtin", "(", "fcode", ",", "exp", ",", "target", ")", ";", "else", "if", "(", "fcode", ">=", "AARCH64_CRC32_BUILTIN_BASE", "&&", "fcode", "<=", "AARCH64_CRC32_BUILTIN_MAX", ")", "return", "aarch64_crc32_expand_builtin", "(", "fcode", ",", "exp", ",", "target", ")", ";", "if", "(", "fcode", "==", "AARCH64_BUILTIN_RSQRT_DF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_SF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_V2DF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_V2SF", "||", "fcode", "==", "AARCH64_BUILTIN_RSQRT_V4SF", ")", "return", "aarch64_expand_builtin_rsqrt", "(", "fcode", ",", "exp", ",", "target", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_EXPAND_BUILTIN", "." ]

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

[]

[ "<s>", "void", "MCS51PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createMCS51ShiftExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "MCS51", "MCS51", "MCS51" ]

[]

[ "<s>", "void", "ix86_split_copysign_const", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "op0", ",", "mask", ",", "x", ";", "dest", "=", "operands", "[", "0", "]", ";", "op0", "=", "operands", "[", "1", "]", ";", "mask", "=", "operands", "[", "3", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "vmode", "=", "GET_MODE", "(", "mask", ")", ";", "dest", "=", "simplify_gen_subreg", "(", "vmode", ",", "dest", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "if", "(", "op0", "!=", "CONST0_RTX", "(", "vmode", ")", ")", "{", "x", "=", "gen_rtx_IOR", "(", "vmode", ",", "dest", ",", "op0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "}", "}", "</s>" ]

[ "Deconstruct", "a", "copysign", "operation", "into", "bit", "masks", ".", "Operand", "0", "is", "known", "to", "be", "a", "constant", ",", "and", "so", "has", "already", "been", "expanded", "into", "a", "vector", "constant", "." ]

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

[]

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

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

[ "AZPR", "\"AZPR Assembly Printer\"" ]

[]

[ "<s>", "bool", "rs6000_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "fntype", ";", "if", "(", "CALL_EXPR_STATIC_CHAIN", "(", "exp", ")", ")", "return", "false", ";", "if", "(", "decl", ")", "fntype", "=", "TREE_TYPE", "(", "decl", ")", ";", "else", "fntype", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "CALL_EXPR_FN", "(", "exp", ")", ")", ")", ";", "if", "(", "TARGET_ALTIVEC_ABI", "&&", "TARGET_ALTIVEC_VRSAVE", "&&", "!", "(", "decl", "&&", "decl", "==", "current_function_decl", ")", ")", "{", "function_args_iterator", "args_iter", ";", "tree", "type", ";", "int", "nvreg", "=", "0", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "++", ";", "FOREACH_FUNCTION_ARGS", "(", "TREE_TYPE", "(", "current_function_decl", ")", ",", "type", ",", "args_iter", ")", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "TYPE_MODE", "(", "type", ")", ")", ")", "nvreg", "--", ";", "if", "(", "nvreg", ">", "0", ")", "return", "false", ";", "}", "if", "(", "rs6000_decl_ok_for_sibcall", "(", "decl", ")", ")", "{", "tree", "attr_list", "=", "TYPE_ATTRIBUTES", "(", "fntype", ")", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "attr_list", ")", "||", "lookup_attribute", "(", "\"shortcall\"", ",", "attr_list", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Say", "whether", "a", "function", "is", "a", "candidate", "for", "sibcall", "handling", "or", "not", ".", "We", "do", "not", "allow", "indirect", "calls", "to", "be", "optimized", "into", "sibling", "calls", ".", "Also", ",", "we", "ca", "n't", "do", "it", "if", "there", "are", "any", "vector", "parameters", ";", "there", "'s", "nowhere", "to", "put", "the", "VRsave", "code", "so", "it", "works", ";", "note", "that", "functions", "with", "vector", "parameters", "are", "required", "to", "have", "a", "prototype", ",", "so", "the", "argument", "type", "info", "must", "be", "available", "here", ".", "(", "The", "tail", "recursion", "case", "can", "work", "with", "vector", "parameters", ",", "but", "there", "'s", "no", "way", "to", "distinguish", "here", ".", ")" ]

[ "rs6000", "0", "0", "\"longcall\"", "\"shortcall\"" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "PPCTargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createPPCISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "hasFusion", "(", ")", "const", "{", "return", "hasFuseAES", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "CPU", "supports", "any", "kind", "of", "instruction", "fusion", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "equals", "(", "const", "CSKYConstantPoolJT", "*", "A", ")", "const", "{", "return", "JTI", "==", "A", "->", "JTI", "&&", "CSKYConstantPoolValue", "::", "equals", "(", "A", ")", ";", "}", "</s>" ]

[ "equals", "-", "Check", "for", "string", "equality", ",", "this", "is", "more", "efficient", "than", "compare", "(", ")", "when", "the", "relative", "ordering", "of", "inequal", "strings", "is", "n't", "needed", "." ]

[ "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "const", "SDNode", "*", "CallNode", ",", "const", "Type", "*", "RetTy", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "Subtarget", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeCallResult", "(", "Ins", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "CallNode", ",", "RetTy", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::InputArg", "16", "Mips", "Mips", "Mips", "0", "1", "2", "ISD::BITCAST" ]

[]

[ "<s>", "void", "SystemZMCAsmBackend", "::", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "{", "unsigned", "Opcode", "=", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "assert", "(", "Opcode", "&&", "\"Unexpected insn to relax\"", ")", ";", "Res", "=", "Inst", ";", "Res", ".", "setOpcode", "(", "Opcode", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Unexpected insn to relax\"" ]

[]

[ "<s>", "bool", "ix86_vec_interleave_v2df_operator_ok", "(", "rtx", "operands", "[", "3", "]", ",", "bool", "high", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "return", "rtx_equal_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "+", "high", "]", ")", ";", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "MEM_P", "(", "operands", "[", "2", "]", ")", ")", "return", "TARGET_SSE3", "&&", "rtx_equal_p", "(", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "the", "operands", "to", "a", "vec_interleave_", "{", "high", ",", "low", "}", "v2df", "are", "ok", ",", "keeping", "in", "mind", "the", "possible", "movddup", "alternative", "." ]

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

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "!", "CurrCycleInstr", ")", "return", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "unsigned", "NumWaitStates", "=", "TII", "->", "getNumWaitStates", "(", "*", "CurrCycleInstr", ")", ";", "EmittedInstrs", ".", "push_front", "(", "CurrCycleInstr", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "std", "::", "min", "(", "NumWaitStates", ",", "getMaxLookAhead", "(", ")", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "EmittedInstrs", ".", "resize", "(", "getMaxLookAhead", "(", ")", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

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

[]

[ "<s>", "void", "TVMRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "LLVMContext", "&", "C", "=", "MF", ".", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "TVMSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "int64_t", "FrameOffset", "=", "MFI", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "assert", "(", "FrameOffset", ">=", "0", "&&", "\"FrameOffset < 0\"", ")", ";", "assert", "(", "FrameOffset", "<", "static_cast", "<", "int64_t", ">", "(", "MFI", ".", "getStackSize", "(", ")", ")", "&&", "\"FrameOffset overflows stack size\"", ")", ";", "assert", "(", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", "!=", "0", "&&", "\"We assume that variable-sized objects have already been lowered, \"", "\"and don't use FrameIndex operands.\"", ")", ";", "unsigned", "RegFrameBase", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "*", "II", ",", "II", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TVM", "::", "GETGLOB", ")", ",", "RegFrameBase", ")", ".", "addImm", "(", "5", ")", ";", "unsigned", "RegFrameOffset", ";", "if", "(", "FrameOffset", "==", "0", ")", "RegFrameOffset", "=", "RegFrameBase", ";", "else", "if", "(", "isInt", "<", "8", ">", "(", "FrameOffset", ")", ")", "{", "RegFrameOffset", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "*", "II", ",", "II", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TVM", "::", "ADDCONST", ")", ",", "RegFrameOffset", ")", ".", "addReg", "(", "RegFrameBase", ")", ".", "addImm", "(", "FrameOffset", ")", ";", "}", "else", "{", "unsigned", "RegConst", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "*", "II", ",", "II", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TVM", "::", "CONST_I257", ")", ",", "RegConst", ")", ".", "addCImm", "(", "cimm", "(", "C", ",", "FrameOffset", ")", ")", ";", "RegFrameOffset", "=", "MRI", ".", "createVirtualRegister", "(", "&", "TVM", "::", "I257RegClass", ")", ";", "BuildMI", "(", "MBB", ",", "*", "II", ",", "II", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TVM", "::", "ADD", ")", ",", "RegFrameOffset", ")", ".", "addReg", "(", "RegFrameBase", ")", ".", "addReg", "(", "RegConst", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "RegFrameOffset", ",", "false", ")", ";", "}", "</s>" ]

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

[ "TVM", "TVM", "0", "TVM", "0", "\"FrameOffset < 0\"", "\"FrameOffset overflows stack size\"", "0", "\"We assume that variable-sized objects have already been lowered, \"", "\"and don't use FrameIndex operands.\"", "TVM::I257RegClass", "TVM::GETGLOB", "5", "0", "8", "TVM::I257RegClass", "TVM::ADDCONST", "TVM::I257RegClass", "TVM::CONST_I257", "TVM::I257RegClass", "TVM::ADD" ]

[]

[ "<s>", "int", "GCNTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsPairwise", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsPairwise", ",", "IsUnsigned", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getHalfRateInstrCost", "(", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "static", "bool", "has_dispatch", "(", "rtx_insn", "*", "insn", ",", "int", "action", ")", "{", "if", "(", "(", "TARGET_BDVER1", "||", "TARGET_BDVER2", "||", "TARGET_BDVER3", "||", "TARGET_BDVER4", "||", "TARGET_ZNVER1", ")", "&&", "flag_dispatch_scheduler", ")", "switch", "(", "action", ")", "{", "default", ":", "return", "false", ";", "case", "IS_DISPATCH_ON", ":", "return", "true", ";", "case", "IS_CMP", ":", "return", "is_cmp", "(", "insn", ")", ";", "case", "DISPATCH_VIOLATION", ":", "return", "dispatch_violation", "(", ")", ";", "case", "FITS_DISPATCH_WINDOW", ":", "return", "fits_dispatch_window", "(", "insn", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "Dispatch", "Scheduling", "is", "supported", "." ]

[ "i386" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SIGN_EXTEND", ":", "return", "LowerSIGN_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntrinsicID", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "unsigned", "NumUserSGPRs", "=", "2", ";", "switch", "(", "IntrinsicID", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "Intrinsic", "::", "r600_read_ngroups_x", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "0", ")", ";", "case", "Intrinsic", "::", "r600_read_ngroups_y", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "4", ")", ";", "case", "Intrinsic", "::", "r600_read_ngroups_z", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "8", ")", ";", "case", "Intrinsic", "::", "r600_read_global_size_x", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "12", ")", ";", "case", "Intrinsic", "::", "r600_read_global_size_y", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "16", ")", ";", "case", "Intrinsic", "::", "r600_read_global_size_z", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "20", ")", ";", "case", "Intrinsic", "::", "r600_read_local_size_x", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "24", ")", ";", "case", "Intrinsic", "::", "r600_read_local_size_y", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "28", ")", ";", "case", "Intrinsic", "::", "r600_read_local_size_z", ":", "return", "LowerParameter", "(", "DAG", ",", "VT", ",", "DL", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "32", ")", ";", "case", "Intrinsic", "::", "r600_read_tgid_x", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ",", "AMDGPU", "::", "SReg_32RegClass", ".", "getRegister", "(", "NumUserSGPRs", "+", "0", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tgid_y", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ",", "AMDGPU", "::", "SReg_32RegClass", ".", "getRegister", "(", "NumUserSGPRs", "+", "1", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tgid_z", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "SReg_32RegClass", ",", "AMDGPU", "::", "SReg_32RegClass", ".", "getRegister", "(", "NumUserSGPRs", "+", "2", ")", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tidig_x", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VReg_32RegClass", ",", "AMDGPU", "::", "VGPR0", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tidig_y", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VReg_32RegClass", ",", "AMDGPU", "::", "VGPR1", ",", "VT", ")", ";", "case", "Intrinsic", "::", "r600_read_tidig_z", ":", "return", "CreateLiveInRegister", "(", "DAG", ",", "&", "AMDGPU", "::", "VReg_32RegClass", ",", "AMDGPU", "::", "VGPR2", ",", "VT", ")", ";", "}", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "R600", "SI", "ISD::BRCOND", "ISD::SELECT_CC", "ISD::SIGN_EXTEND", "SI", "ISD::INTRINSIC_WO_CHAIN", "0", "2", "Intrinsic::r600_read_ngroups_x", "0", "Intrinsic::r600_read_ngroups_y", "4", "Intrinsic::r600_read_ngroups_z", "8", "Intrinsic::r600_read_global_size_x", "12", "Intrinsic::r600_read_global_size_y", "16", "Intrinsic::r600_read_global_size_z", "20", "Intrinsic::r600_read_local_size_x", "24", "Intrinsic::r600_read_local_size_y", "28", "Intrinsic::r600_read_local_size_z", "32", "Intrinsic::r600_read_tgid_x", "0", "Intrinsic::r600_read_tgid_y", "1", "Intrinsic::r600_read_tgid_z", "2", "Intrinsic::r600_read_tidig_x", "Intrinsic::r600_read_tidig_y", "Intrinsic::r600_read_tidig_z" ]

[]

[ "<s>", "static", "int", "rs6000_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", ")", "{", "unsigned", "elements", ";", "tree", "elem_type", ";", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "case", "scalar_store", ":", "case", "vector_stmt", ":", "case", "vector_store", ":", "case", "vec_to_scalar", ":", "case", "scalar_to_vec", ":", "case", "cond_branch_not_taken", ":", "return", "1", ";", "case", "scalar_load", ":", "case", "vector_load", ":", "return", "2", ";", "case", "vec_perm", ":", "if", "(", "TARGET_VSX", "&&", "rs6000_tune", "==", "PROCESSOR_POWER7", ")", "return", "3", ";", "else", "return", "1", ";", "case", "vec_promote_demote", ":", "if", "(", "TARGET_VSX", "&&", "rs6000_tune", "==", "PROCESSOR_POWER7", ")", "return", "4", ";", "else", "return", "1", ";", "case", "cond_branch_taken", ":", "return", "3", ";", "case", "unaligned_load", ":", "case", "vector_gather_load", ":", "if", "(", "TARGET_EFFICIENT_UNALIGNED_VSX", ")", "return", "2", ";", "if", "(", "TARGET_VSX", "&&", "TARGET_ALLOW_MOVMISALIGN", ")", "{", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "if", "(", "elements", "==", "2", "||", "elements", "==", "1", ")", "return", "4", ";", "if", "(", "elements", "==", "4", ")", "{", "switch", "(", "misalign", ")", "{", "case", "8", ":", "return", "4", ";", "case", "-", "1", ":", "case", "4", ":", "case", "12", ":", "return", "33", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "if", "(", "TARGET_ALTIVEC", ")", "gcc_unreachable", "(", ")", ";", "return", "4", ";", "case", "unaligned_store", ":", "case", "vector_scatter_store", ":", "if", "(", "TARGET_EFFICIENT_UNALIGNED_VSX", ")", "return", "1", ";", "if", "(", "TARGET_VSX", "&&", "TARGET_ALLOW_MOVMISALIGN", ")", "{", "elements", "=", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ";", "if", "(", "elements", "==", "2", "||", "elements", "==", "1", ")", "return", "2", ";", "if", "(", "elements", "==", "4", ")", "{", "switch", "(", "misalign", ")", "{", "case", "8", ":", "return", "2", ";", "case", "-", "1", ":", "case", "4", ":", "case", "12", ":", "return", "23", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "if", "(", "TARGET_ALTIVEC", ")", "gcc_unreachable", "(", ")", ";", "return", "2", ";", "case", "vec_construct", ":", "elem_type", "=", "TREE_TYPE", "(", "vectype", ")", ";", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "elem_type", ")", "&&", "TYPE_PRECISION", "(", "elem_type", ")", "==", "32", ")", "return", "5", ";", "else", "if", "(", "INTEGRAL_TYPE_P", "(", "elem_type", ")", ")", "{", "if", "(", "TARGET_P9_VECTOR", ")", "return", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", "-", "1", "+", "2", ";", "else", "return", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", "-", "1", "+", "5", ";", "}", "else", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

[ "rs6000", "1", "2", "3", "1", "4", "1", "3", "2", "2", "1", "4", "4", "8", "4", "1", "4", "12", "33", "4", "1", "2", "1", "2", "4", "8", "2", "1", "4", "12", "23", "2", "32", "5", "1", "2", "1", "5", "2" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createSIMemoryLegalizerPass", "(", ")", ")", ";", "addPass", "(", "createSIInsertWaitcntsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSIModeRegisterPass", "(", ")", ")", ";", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "addPass", "(", "&", "SIInsertHardClausesID", ")", ";", "addPass", "(", "&", "SIRemoveShortExecBranchesID", ")", ";", "addPass", "(", "&", "SIPreEmitPeepholeID", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Relocator", "::", "Result", "unsupported", "(", "Relocation", "&", "pReloc", ",", "X86_64Relocator", "&", "pParent", ")", "{", "return", "Relocator", "::", "Unsupported", ";", "}", "</s>" ]

[ "The", "instruction", "is", "unsupported", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "return", "NumCycles", "==", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "ARM", "1" ]

[]

[ "<s>", "static", "bool", "cdx_and_immed", "(", "rtx", "op", ")", "{", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "{", "HOST_WIDE_INT", "ival", "=", "INTVAL", "(", "op", ")", ";", "return", "(", "ival", "==", "1", "||", "ival", "==", "2", "||", "ival", "==", "3", "||", "ival", "==", "4", "||", "ival", "==", "8", "||", "ival", "==", "0xf", "||", "ival", "==", "0x10", "||", "ival", "==", "0x1f", "||", "ival", "==", "0x20", "||", "ival", "==", "0x3f", "||", "ival", "==", "0x7f", "||", "ival", "==", "0x80", "||", "ival", "==", "0xff", "||", "ival", "==", "0x7ff", "||", "ival", "==", "0xff00", "||", "ival", "==", "0xffff", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "OP", "is", "within", "range", "of", "CDX", "andi.n", "immediates", "." ]

[ "nios2", "1", "2", "3", "4", "8", "0xf", "0x10", "0x1f", "0x20", "0x3f", "0x7f", "0x80", "0xff", "0x7ff", "0xff00", "0xffff" ]

[]

[ "<s>", "tree", "i386_pe_mangle_decl_assembler_name", "(", "tree", "decl", ",", "tree", "id", ")", "{", "tree", "new_id", "=", "i386_pe_maybe_mangle_decl_assembler_name", "(", "decl", ",", "id", ")", ";", "return", "(", "new_id", "?", "new_id", ":", "id", ")", ";", "}", "</s>" ]

[ "This", "is", "used", "as", "a", "target", "hook", "to", "modify", "the", "DECL_ASSEMBLER_NAME", "in", "the", "language-independent", "default", "hook", "langhooks", ",", "c", ":", "lhd_set_decl_assembler_name", "(", ")", "and", "in", "cp/mangle", ",", "c", ":", "mangle_decl", "(", ")", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "gen_ashift_hi", "(", "int", "type", ",", "int", "n", ",", "rtx", "reg", ")", "{", "if", "(", "n", "<", "0", ")", "{", "if", "(", "type", "==", "ASHIFT", ")", "type", "=", "LSHIFTRT", ";", "else", "type", "=", "ASHIFT", ";", "n", "=", "-", "n", ";", "}", "switch", "(", "type", ")", "{", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "{", "int", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "offset", "=", "SUBREG_BYTE", "(", "reg", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "gen_ashift", "(", "type", ",", "n", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "reg", ",", "offset", ")", ")", ";", "break", ";", "}", "case", "ASHIFT", ":", "emit_insn", "(", "gen_ashlhi3_k", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "n", ")", ")", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Same", "for", "HImode" ]

[ "sh", "0", "0" ]

[]

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

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

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

[]

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

[ "Return", "true", "if", "calls", "to", "the", "function", "could", "modify", "some", "form", "of", "global", "state", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "if", "(", "needsExpansion", "(", "Inst", ")", ")", "{", "SmallVector", "<", "MCInst", ",", "4", ">", "Instructions", ";", "expandInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Instructions", ".", "size", "(", ")", ";", "i", "++", ")", "{", "Out", ".", "EmitInstruction", "(", "Instructions", "[", "i", "]", ")", ";", "}", "}", "else", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "}", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "Error", "(", "IDLoc", ",", "\"instruction requires a CPU feature not currently enabled\"", ")", ";", "return", "true", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MipsOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "4", "0", "\"instruction requires a CPU feature not currently enabled\"", "0U", "\"too few operands for instruction\"", "Mips", "\"invalid operand for instruction\"", "\"invalid instruction\"" ]

[]

[ "<s>", "void", "AnalyzeCallResult", "(", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "CCAssignFn", "Fn", ",", "const", "Type", "*", "RetTy", ",", "const", "char", "*", "Func", ")", "{", "PreAnalyzeCallResult", "(", "Ins", ",", "Fn", ",", "RetTy", ",", "Func", ")", ";", "CCState", "::", "AnalyzeCallResult", "(", "Ins", ",", "Fn", ")", ";", "}", "</s>" ]

[ "AnalyzeCallResult", "-", "Same", "as", "above", "except", "it", "'s", "specialized", "for", "calls", "which", "produce", "a", "single", "value", "." ]

[ "Mips", "ISD::InputArg" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "return", "Outs", ".", "size", "(", ")", "<=", "1", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "WebAssembly", "WebAssembly", "ISD::OutputArg", "1" ]

[]

[ "<s>", "const", "int", "*", "HexagonRegisterInfo", "::", "getRegClassPressureSets", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "static", "const", "int", "RCSetsTable", "[", "]", "=", "{", "0", ",", "-", "1", ",", "1", ",", "-", "1", ",", "2", ",", "-", "1", ",", "0", ",", "-", "1", ",", "-", "1", "}", ";", "static", "const", "unsigned", "RCSetStartTable", "[", "]", "=", "{", "0", ",", "2", ",", "4", ",", "6", ",", "0", "}", ";", "unsigned", "SetListStart", "=", "RCSetStartTable", "[", "RC", "->", "getID", "(", ")", "]", ";", "return", "&", "RCSetsTable", "[", "SetListStart", "]", ";", "}", "</s>" ]

[ "Get", "the", "dimensions", "of", "register", "pressure", "impacted", "by", "this", "register", "class", "." ]

[ "Hexagon", "Hexagon", "0", "1", "1", "1", "2", "1", "0", "1", "1", "0", "2", "4", "6", "0" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "addPass", "(", "new", "Legalizer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "legalize", "pass", ",", "which", "converts", "the", "instruction", "sequence", "into", "one", "that", "can", "be", "selected", "by", "the", "target", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "MCS51RelaxMem", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Modified", "=", "false", ";", "const", "MCS51Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "Block", "&", "MBB", ":", "MF", ")", "{", "bool", "BlockModified", "=", "runOnBasicBlock", "(", "MBB", ")", ";", "Modified", "|=", "BlockModified", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51" ]

[]

[ "<s>", "void", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "override", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "VE" ]

[]

[ "<s>", "const", "char", "*", "output_ubranch", "(", "rtx", "label", ",", "rtx_insn", "*", "insn", ")", "{", "return", "output_branch", "(", "label", ",", "\"tr\"", ",", "insn", ")", ";", "}", "</s>" ]

[ "Output", "an", "unconditional", "branch", "to", "LABEL", ".", "INSN", "is", "the", "instruction", "." ]

[ "visium", "\"tr\"" ]

[]

[ "<s>", "static", "void", "avr_adjust_type_node", "(", "tree", "*", "node", ",", "machine_mode", "mode", ",", "int", "sat_p", ")", "{", "*", "node", "=", "make_node", "(", "FIXED_POINT_TYPE", ")", ";", "TYPE_SATURATING", "(", "*", "node", ")", "=", "sat_p", ";", "TYPE_UNSIGNED", "(", "*", "node", ")", "=", "UNSIGNED_FIXED_POINT_MODE_P", "(", "mode", ")", ";", "TYPE_IBIT", "(", "*", "node", ")", "=", "GET_MODE_IBIT", "(", "mode", ")", ";", "TYPE_FBIT", "(", "*", "node", ")", "=", "GET_MODE_FBIT", "(", "mode", ")", ";", "TYPE_PRECISION", "(", "*", "node", ")", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "TYPE_ALIGN", "(", "*", "node", ")", "=", "8", ";", "SET_TYPE_MODE", "(", "*", "node", ",", "mode", ")", ";", "layout_type", "(", "*", "node", ")", ";", "}", "</s>" ]

[ "Helper", "for", "the", "function", "below", "." ]

[ "avr", "8" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "auto", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "1", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AArch64", "1" ]

[]

[ "<s>", "bool", "mips_const_vector_bitimm_clr_p", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", "&&", "op", "!=", "CONSTM1_RTX", "(", "mode", ")", ")", "{", "unsigned", "HOST_WIDE_INT", "val", "=", "~", "UINTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", ";", "int", "vlog2", "=", "exact_log2", "(", "val", "&", "GET_MODE_MASK", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ")", ";", "if", "(", "vlog2", "!=", "-", "1", ")", "{", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", ";", "gcc_assert", "(", "vlog2", ">=", "0", "&&", "vlog2", "<=", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", "-", "1", ")", ";", "return", "mips_const_vector_same_val_p", "(", "op", ",", "mode", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "constant", "vector", "with", "the", "number", "of", "units", "in", "MODE", ",", "and", "each", "unit", "has", "the", "same", "bit", "clear", "." ]

[ "mips", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "int", "write_init_file", "(", "void", ")", "{", "write_autogenerated_header", "(", "init_file", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"config.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"system.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"coretypes.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"backend.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"rtl.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"tree.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"langhooks.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"insn-codes.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"#include \\\"rs6000-builtins.h\\\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"tree rs6000_builtin_decls[RS6000_OVLD_MAX];\\n\\n\"", ")", ";", "write_bif_static_init", "(", ")", ";", "write_ovld_static_init", "(", ")", ";", "fprintf", "(", "init_file", ",", "\"void\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"rs6000_init_generated_builtins ()\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\"{\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" tree t;\\n\"", ")", ";", "rbt_inorder_callback", "(", "&", "fntype_rbt", ",", "fntype_rbt", ".", "rbt_root", ",", "write_fntype_init", ")", ";", "fprintf", "(", "init_file", ",", "\"\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_decls[RS6000_BIF_NONE] = NULL_TREE;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_decls[RS6000_BIF_MAX] = NULL_TREE;\\n\"", ")", ";", "fprintf", "(", "init_file", ",", "\" rs6000_builtin_decls[RS6000_OVLD_NONE] = NULL_TREE;\\n\\n\"", ")", ";", "write_init_bif_table", "(", ")", ";", "write_init_ovld_table", "(", ")", ";", "fprintf", "(", "init_file", ",", "\"}\\n\\n\"", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Write", "everything", "to", "the", "initialization", "file", "(", "rs6000-builtins.cc", ")", ".", "Return", "1", "if", "successful", ",", "0", "otherwise", "." ]

[ "rs6000", "\"#include \\\"config.h\\\"\\n\"", "\"#include \\\"system.h\\\"\\n\"", "\"#include \\\"coretypes.h\\\"\\n\"", "\"#include \\\"backend.h\\\"\\n\"", "\"#include \\\"rtl.h\\\"\\n\"", "\"#include \\\"tree.h\\\"\\n\"", "\"#include \\\"langhooks.h\\\"\\n\"", "\"#include \\\"insn-codes.h\\\"\\n\"", "\"#include \\\"rs6000-builtins.h\\\"\\n\"", "\"\\n\"", "\"tree rs6000_builtin_decls[RS6000_OVLD_MAX];\\n\\n\"", "\"void\\n\"", "\"rs6000_init_generated_builtins ()\\n\"", "\"{\\n\"", "\" tree t;\\n\"", "\"\\n\"", "\" rs6000_builtin_decls[RS6000_BIF_NONE] = NULL_TREE;\\n\"", "\" rs6000_builtin_decls[RS6000_BIF_MAX] = NULL_TREE;\\n\"", "\" rs6000_builtin_decls[RS6000_OVLD_NONE] = NULL_TREE;\\n\\n\"", "\"}\\n\\n\"", "1" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SNESTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "SNES", "::", "Lsl8", ":", "case", "SNES", "::", "Lsl16", ":", "case", "SNES", "::", "Lsr8", ":", "case", "SNES", "::", "Lsr16", ":", "case", "SNES", "::", "Rol8", ":", "case", "SNES", "::", "Rol16", ":", "case", "SNES", "::", "Ror8", ":", "case", "SNES", "::", "Ror16", ":", "case", "SNES", "::", "Asr8", ":", "case", "SNES", "::", "Asr16", ":", "return", "insertShift", "(", "MI", ",", "MBB", ")", ";", "case", "SNES", "::", "MULRdRr", ":", "case", "SNES", "::", "MULSRdRr", ":", "return", "insertMul", "(", "MI", ",", "MBB", ")", ";", "}", "assert", "(", "(", "Opc", "==", "SNES", "::", "Select16", "||", "Opc", "==", "SNES", "::", "Select8", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "SNESInstrInfo", "&", "TII", "=", "(", "const", "SNESInstrInfo", "&", ")", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "MBB", "->", "getBasicBlock", "(", ")", ";", "MachineBasicBlock", "*", "trueMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "falseMBB", "=", "MF", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineFunction", "::", "iterator", "I", ";", "for", "(", "I", "=", "MF", "->", "begin", "(", ")", ";", "I", "!=", "MF", "->", "end", "(", ")", "&&", "&", "(", "*", "I", ")", "!=", "MBB", ";", "++", "I", ")", ";", "if", "(", "I", "!=", "MF", "->", "end", "(", ")", ")", "++", "I", ";", "MF", "->", "insert", "(", "I", ",", "trueMBB", ")", ";", "MF", "->", "insert", "(", "I", ",", "falseMBB", ")", ";", "trueMBB", "->", "splice", "(", "trueMBB", "->", "begin", "(", ")", ",", "MBB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "MBB", "->", "end", "(", ")", ")", ";", "trueMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "MBB", ")", ";", "SNESCC", "::", "CondCodes", "CC", "=", "(", "SNESCC", "::", "CondCodes", ")", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "BuildMI", "(", "MBB", ",", "dl", ",", "TII", ".", "getBrCond", "(", "CC", ")", ")", ".", "addMBB", "(", "trueMBB", ")", ";", "BuildMI", "(", "MBB", ",", "dl", ",", "TII", ".", "get", "(", "SNES", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "falseMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "falseMBB", ")", ";", "MBB", "->", "addSuccessor", "(", "trueMBB", ")", ";", "BuildMI", "(", "falseMBB", ",", "dl", ",", "TII", ".", "get", "(", "SNES", "::", "RJMPk", ")", ")", ".", "addMBB", "(", "trueMBB", ")", ";", "falseMBB", "->", "addSuccessor", "(", "trueMBB", ")", ";", "BuildMI", "(", "*", "trueMBB", ",", "trueMBB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "SNES", "::", "PHI", ")", ",", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "MBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "falseMBB", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "trueMBB", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "SNES::Lsl8", "SNES::Lsl16", "SNES::Lsr8", "SNES::Lsr16", "SNES::Rol8", "SNES::Rol16", "SNES::Ror8", "SNES::Ror16", "SNES::Asr8", "SNES::Asr16", "SNES::MULRdRr", "SNES::MULSRdRr", "SNES::Select16", "SNES::Select8", "\"Unexpected instr type to insert\"", "SNES", "SNES", "SNESCC::CondCodes", "SNESCC::CondCodes", "3", "SNES::RJMPk", "SNES::RJMPk", "SNES::PHI", "0", "1", "2" ]

[]

[ "<s>", "unsigned", "GBZ80InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "GB", "::", "ST8_FI", ":", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "GBZ80", "GB", "GB::ST8_FI", "1", "0", "1", "0" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "if", "(", "Ins", ".", "empty", "(", ")", ")", "return", "Chain", ";", "else", "{", "llvm_report_error", "(", "\"ISRs cannot have arguments\"", ")", ";", "return", "SDValue", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot have arguments\"" ]

[]

[ "<s>", "void", "HexagonCommonGEP", "::", "materialize", "(", "NodeToValueMap", "&", "Loc", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Nodes before materialization:\\n\"", "<<", "Nodes", "<<", "'\\n'", ")", ";", "NodeChildrenMap", "NCM", ";", "NodeVect", "Roots", ";", "invert_find_roots", "(", "Nodes", ",", "NCM", ",", "Roots", ")", ";", "while", "(", "!", "Roots", ".", "empty", "(", ")", ")", "{", "NodeVect", "::", "iterator", "First", "=", "Roots", ".", "begin", "(", ")", ";", "GepNode", "*", "Root", "=", "*", "First", ",", "*", "Last", "=", "*", "First", ";", "Roots", ".", "erase", "(", "First", ")", ";", "NodeVect", "NA", ";", "bool", "LastUsed", "=", "false", ";", "unsigned", "LastCN", "=", "0", ";", "Value", "*", "LocV", "=", "Loc", "[", "Last", "]", ";", "if", "(", "!", "LocV", ")", "continue", ";", "BasicBlock", "*", "LastB", "=", "cast", "<", "BasicBlock", ">", "(", "LocV", ")", ";", "do", "{", "NA", ".", "push_back", "(", "Last", ")", ";", "LastUsed", "=", "(", "Last", "->", "Flags", "&", "GepNode", "::", "Used", ")", ";", "if", "(", "LastUsed", ")", "break", ";", "NodeChildrenMap", "::", "iterator", "CF", "=", "NCM", ".", "find", "(", "Last", ")", ";", "LastCN", "=", "(", "CF", "!=", "NCM", ".", "end", "(", ")", ")", "?", "CF", "->", "second", ".", "size", "(", ")", ":", "0", ";", "if", "(", "LastCN", "!=", "1", ")", "break", ";", "GepNode", "*", "Child", "=", "CF", "->", "second", ".", "front", "(", ")", ";", "BasicBlock", "*", "ChildB", "=", "cast_or_null", "<", "BasicBlock", ">", "(", "Loc", "[", "Child", "]", ")", ";", "if", "(", "ChildB", "!=", "0", "&&", "LastB", "!=", "ChildB", ")", "break", ";", "Last", "=", "Child", ";", "}", "while", "(", "true", ")", ";", "BasicBlock", "::", "iterator", "InsertAt", "=", "LastB", "->", "getTerminator", "(", ")", ";", "if", "(", "LastUsed", "||", "LastCN", ">", "0", ")", "{", "ValueVect", "Urs", ";", "getAllUsersForNode", "(", "Root", ",", "Urs", ",", "NCM", ")", ";", "BasicBlock", "::", "iterator", "FirstUse", "=", "first_use_of_in_block", "(", "Urs", ",", "LastB", ")", ";", "if", "(", "FirstUse", "!=", "LastB", "->", "end", "(", ")", ")", "InsertAt", "=", "FirstUse", ";", "}", "Value", "*", "NewInst", "=", "fabricateGEP", "(", "NA", ",", "InsertAt", ",", "LastB", ")", ";", "if", "(", "LastCN", ">", "0", ")", "{", "NodeVect", "&", "Cs", "=", "NCM", "[", "Last", "]", ";", "for", "(", "NodeVect", "::", "iterator", "I", "=", "Cs", ".", "begin", "(", ")", ",", "E", "=", "Cs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "GepNode", "*", "CN", "=", "*", "I", ";", "CN", "->", "Flags", "&=", "~", "GepNode", "::", "Internal", ";", "CN", "->", "Flags", "|=", "GepNode", "::", "Root", ";", "CN", "->", "BaseVal", "=", "NewInst", ";", "Roots", ".", "push_back", "(", "CN", ")", ";", "}", "}", "if", "(", "LastUsed", ")", "{", "NodeToUsesMap", "::", "iterator", "UF", "=", "Uses", ".", "find", "(", "Last", ")", ";", "assert", "(", "UF", "!=", "Uses", ".", "end", "(", ")", "&&", "\"No use information found\"", ")", ";", "UseSet", "&", "Us", "=", "UF", "->", "second", ";", "for", "(", "UseSet", "::", "iterator", "I", "=", "Us", ".", "begin", "(", ")", ",", "E", "=", "Us", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Use", "*", "U", "=", "*", "I", ";", "U", "->", "set", "(", "NewInst", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "This", "method", "can", "be", "implemented", "to", "generate", "a", "mapped", "Value", "on", "demand", "." ]

[ "Hexagon", "Hexagon", "\"Nodes before materialization:\\n\"", "0", "0", "1", "0", "0", "0", "\"No use information found\"" ]

[]

[ "<s>", "static", "int", "mips_multipass_dfa_lookahead", "(", "void", ")", "{", "if", "(", "TUNE_SB1", ")", "return", "4", ";", "if", "(", "TUNE_LOONGSON_2EF", "||", "TUNE_GS464", "||", "TUNE_GS464E", ")", "return", "4", ";", "if", "(", "TUNE_OCTEON", "||", "TUNE_GS264E", ")", "return", "2", ";", "if", "(", "TUNE_P5600", "||", "TUNE_P6600", "||", "TUNE_I6400", ")", "return", "4", ";", "return", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Wasn't expecting to be able to lower this!\"", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAMPOLINE", ":", "return", "LowerTRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "STACKRESTORE", ":", "return", "LowerSTACKRESTORE", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ",", "PPCSubTarget", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "Op", ".", "getDebugLoc", "(", ")", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLT_ROUNDS_", ":", "return", "LowerFLT_ROUNDS_", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerSHL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "LowerSRL_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerSRA_PARTS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "return", "LowerSCALAR_TO_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "LowerMUL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Wasn't expecting to be able to lower this!\"", "ISD::ConstantPool", "ISD::BlockAddress", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SETCC", "ISD::TRAMPOLINE", "ISD::VASTART", "PPC", "ISD::VAARG", "PPC", "ISD::STACKRESTORE", "PPC", "ISD::DYNAMIC_STACKALLOC", "PPC", "ISD::SELECT_CC", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "ISD::SINT_TO_FP", "ISD::FLT_ROUNDS_", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::INTRINSIC_WO_CHAIN", "ISD::SCALAR_TO_VECTOR", "ISD::MUL", "ISD::RETURNADDR", "ISD::FRAMEADDR" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "ARMBaseRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "MCPhysReg", "*", "RegList", "=", "STI", ".", "isTargetDarwin", "(", ")", "?", "CSR_iOS_SaveList", ":", "CSR_AAPCS_SaveList", ";", "if", "(", "!", "MF", ")", "return", "RegList", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "if", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "{", "return", "CSR_NoRegs_SaveList", ";", "}", "else", "if", "(", "F", "->", "hasFnAttribute", "(", "\"interrupt\"", ")", ")", "{", "if", "(", "STI", ".", "isMClass", "(", ")", ")", "{", "return", "CSR_AAPCS_SaveList", ";", "}", "else", "if", "(", "F", "->", "getFnAttribute", "(", "\"interrupt\"", ")", ".", "getValueAsString", "(", ")", "==", "\"FIQ\"", ")", "{", "return", "CSR_FIQ_SaveList", ";", "}", "else", "{", "return", "CSR_GenericInt_SaveList", ";", "}", "}", "return", "RegList", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"interrupt\"", "\"interrupt\"", "\"FIQ\"" ]

[]

[ "<s>", "static", "void", "ix86_store_returned_bounds", "(", "rtx", "slot", ",", "rtx", "bounds", ")", "{", "gcc_assert", "(", "REG_P", "(", "slot", ")", ")", ";", "emit_move_insn", "(", "slot", ",", "bounds", ")", ";", "}", "</s>" ]

[ "Store", "BOUNDS", "returned", "by", "function", "into", "SLOT", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "case", "AMDGPU", "::", "SI_CONSTDATA_PTR", ":", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "RegLo", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "RegHi", "=", "RI", ".", "getSubReg", "(", "Reg", ",", "AMDGPU", "::", "sub1", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "RegLo", ")", ".", "addReg", "(", "RegLo", ")", ".", "addTargetIndex", "(", "AMDGPU", "::", "TI_CONSTDATA_START", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ",", "RegHi", ")", ".", "addReg", "(", "RegHi", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "AMDGPU", "::", "SCC", ",", "RegState", "::", "Implicit", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SGPR_USE", ":", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "R600", "SI", "SI", "0", "0" ]

[]

[ "<s>", "static", "rtx", "s390_find_constant", "(", "struct", "constant_pool", "*", "pool", ",", "rtx", "val", ",", "enum", "machine_mode", "mode", ")", "{", "struct", "constant", "*", "c", ";", "rtx", "offset", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NR_C_MODES", ";", "i", "++", ")", "if", "(", "constant_modes", "[", "i", "]", "==", "mode", ")", "break", ";", "gcc_assert", "(", "i", "!=", "NR_C_MODES", ")", ";", "for", "(", "c", "=", "pool", "->", "constants", "[", "i", "]", ";", "c", "!=", "NULL", ";", "c", "=", "c", "->", "next", ")", "if", "(", "rtx_equal_p", "(", "val", ",", "c", "->", "value", ")", ")", "break", ";", "gcc_assert", "(", "c", ")", ";", "offset", "=", "gen_rtx_MINUS", "(", "Pmode", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "c", "->", "label", ")", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "pool", "->", "label", ")", ")", ";", "offset", "=", "gen_rtx_CONST", "(", "Pmode", ",", "offset", ")", ";", "return", "offset", ";", "}", "</s>" ]

[ "Find", "constant", "VAL", "of", "mode", "MODE", "in", "the", "constant", "pool", "POOL", ".", "Return", "an", "RTX", "describing", "the", "distance", "from", "the", "start", "of", "the", "pool", "to", "the", "location", "of", "the", "new", "constant", "." ]

[ "s390", "0" ]

[]

[ "<s>", "static", "bool", "cris_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "enum", "cris_symbol_type", "t", "=", "cris_symbol_type_of", "(", "x", ")", ";", "return", "t", "==", "cris_unspec", "||", "t", "==", "cris_got_symbol", "||", "t", "==", "cris_rel_symbol", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_CANNOT_FORCE_CONST_MEM", ".", "We", "ca", "n't", "put", "PIC", "addresses", "in", "the", "constant", "pool", ",", "not", "even", "the", "ones", "that", "can", "be", "reached", "as", "pc-relative", "as", "we", "ca", "n't", "tell", "when", "or", "how", "to", "do", "that", "." ]

[ "cris" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "restoreWin32EHStackPointers", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "bool", "RestoreSP", ")", "const", "{", "assert", "(", "STI", ".", "isTargetWindowsMSVC", "(", ")", "&&", "\"funclets only supported in MSVC env\"", ")", ";", "assert", "(", "STI", ".", "isTargetWin32", "(", ")", "&&", "\"EBP/ESI restoration only required on win32\"", ")", ";", "assert", "(", "STI", ".", "is32Bit", "(", ")", "&&", "!", "Uses64BitFramePtr", "&&", "\"restoring EBP/ESI on non-32-bit target\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "Register", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "Register", "BasePtr", "=", "TRI", "->", "getBaseRegister", "(", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "*", "MF", ".", "getWinEHFuncInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "FuncInfo", ".", "EHRegNodeFrameIndex", ";", "int", "EHRegSize", "=", "MFI", ".", "getObjectSize", "(", "FI", ")", ";", "if", "(", "RestoreSP", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "X86", "::", "ESP", ")", ",", "X86", "::", "EBP", ",", "true", ",", "-", "EHRegSize", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "unsigned", "UsedReg", ";", "int", "EHRegOffset", "=", "getFrameIndexReference", "(", "MF", ",", "FI", ",", "UsedReg", ")", ";", "int", "EndOffset", "=", "-", "EHRegOffset", "-", "EHRegSize", ";", "FuncInfo", ".", "EHRegNodeEndOffset", "=", "EndOffset", ";", "if", "(", "UsedReg", "==", "FramePtr", ")", "{", "unsigned", "ADDri", "=", "getADDriOpcode", "(", "false", ",", "EndOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "ADDri", ")", ",", "FramePtr", ")", ".", "addReg", "(", "FramePtr", ")", ".", "addImm", "(", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "assert", "(", "EndOffset", ">=", "0", "&&", "\"end of registration object above normal EBP position!\"", ")", ";", "}", "else", "if", "(", "UsedReg", "==", "BasePtr", ")", "{", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "LEA32r", ")", ",", "BasePtr", ")", ",", "FramePtr", ",", "false", ",", "EndOffset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "assert", "(", "X86FI", "->", "getHasSEHFramePtrSave", "(", ")", ")", ";", "int", "Offset", "=", "getFrameIndexReference", "(", "MF", ",", "X86FI", "->", "getSEHFramePtrSaveIndex", "(", ")", ",", "UsedReg", ")", ";", "assert", "(", "UsedReg", "==", "BasePtr", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "MOV32rm", ")", ",", "FramePtr", ")", ",", "UsedReg", ",", "true", ",", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"", ")", ";", "}", "return", "MBBI", ";", "}", "</s>" ]

[ "Sets", "up", "EBP", "and", "optionally", "ESI", "based", "on", "the", "incoming", "EBP", "value", "." ]

[ "X86", "X86", "\"funclets only supported in MSVC env\"", "\"EBP/ESI restoration only required on win32\"", "\"restoring EBP/ESI on non-32-bit target\"", "X86", "X86", "X86", "X86::MOV32rm", "X86::ESP", "X86::EBP", "3", "0", "\"end of registration object above normal EBP position!\"", "X86::LEA32r", "X86", "X86", "X86::MOV32rm", "\"32-bit frames with WinEH must use FramePtr or BasePtr\"" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "ARM", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_arm_ldst_pcrel_12\"", ",", "1", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_ldst_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_pcrel_10\"", ",", "1", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_pcrel_10\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_thumb_adr_pcrel_10\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_adr_pcrel_12\"", ",", "1", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_adr_pcrel_12\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsAlignedDownTo32Bits", "}", ",", "{", "\"fixup_arm_condbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_uncondbranch\"", ",", "0", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_condbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_uncondbranch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_br\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bl\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_blx\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cb\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_cp\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_thumb_bcc\"", ",", "0", ",", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movt_hi16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_t2_movw_lo16\"", ",", "0", ",", "20", ",", "0", "}", ",", "{", "\"fixup_arm_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_arm_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movt_hi16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_t2_movw_lo16_pcrel\"", ",", "0", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "ARM", "ARM::NumTargetFixupKinds", "\"fixup_arm_ldst_pcrel_12\"", "1", "24", "\"fixup_t2_ldst_pcrel_12\"", "0", "32", "\"fixup_arm_pcrel_10\"", "1", "24", "\"fixup_t2_pcrel_10\"", "0", "32", "\"fixup_thumb_adr_pcrel_10\"", "0", "8", "\"fixup_arm_adr_pcrel_12\"", "1", "24", "\"fixup_t2_adr_pcrel_12\"", "0", "32", "\"fixup_arm_condbranch\"", "0", "24", "\"fixup_arm_uncondbranch\"", "0", "24", "\"fixup_t2_condbranch\"", "0", "32", "\"fixup_t2_uncondbranch\"", "0", "32", "\"fixup_arm_thumb_br\"", "0", "16", "\"fixup_arm_thumb_bl\"", "0", "32", "\"fixup_arm_thumb_blx\"", "0", "32", "\"fixup_arm_thumb_cb\"", "0", "16", "\"fixup_arm_thumb_cp\"", "0", "8", "\"fixup_arm_thumb_bcc\"", "0", "8", "\"fixup_arm_movt_hi16\"", "0", "20", "0", "\"fixup_arm_movw_lo16\"", "0", "20", "0", "\"fixup_t2_movt_hi16\"", "0", "20", "0", "\"fixup_t2_movw_lo16\"", "0", "20", "0", "\"fixup_arm_movt_hi16_pcrel\"", "0", "20", "\"fixup_arm_movw_lo16_pcrel\"", "0", "20", "\"fixup_t2_movt_hi16_pcrel\"", "0", "20", "\"fixup_t2_movw_lo16_pcrel\"", "0", "20", "\"Invalid kind!\"" ]

[]

[ "<s>", "unsigned", "TOYInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "assert", "(", "0", "&&", "\"Unimplemented\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "TOY", "TOY", "0", "\"Unimplemented\"", "0" ]

[]

[ "<s>", "void", "arm_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "bdst", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ",", "x", ";", "machine_mode", "mode", ",", "cmp_mode", ";", "bval", "=", "operands", "[", "0", "]", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "operands", "[", "5", "]", ";", "mod_s", "=", "operands", "[", "6", "]", ";", "mod_f", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "if", "(", "TARGET_HAVE_LDACQ", "&&", "is_mm_acquire", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_f", ")", ")", ")", "&&", "is_mm_release", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_s", ")", ")", ")", ")", "mod_s", "=", "GEN_INT", "(", "MEMMODEL_ACQ_REL", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "rval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "case", "E_SImode", ":", "if", "(", "!", "arm_add_operand", "(", "oldval", ",", "SImode", ")", ")", "oldval", "=", "force_reg", "(", "SImode", ",", "oldval", ")", ";", "break", ";", "case", "E_DImode", ":", "if", "(", "!", "cmpdi_operand", "(", "oldval", ",", "mode", ")", ")", "oldval", "=", "force_reg", "(", "mode", ",", "oldval", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "TARGET_THUMB1", ")", "cmp_mode", "=", "E_SImode", ";", "else", "cmp_mode", "=", "CC_Zmode", ";", "bdst", "=", "TARGET_THUMB1", "?", "bval", ":", "gen_rtx_REG", "(", "CC_Zmode", ",", "CC_REGNUM", ")", ";", "emit_insn", "(", "gen_atomic_compare_and_swap_1", "(", "cmp_mode", ",", "mode", ",", "bdst", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "gen_lowpart", "(", "mode", ",", "rval", ")", ")", ";", "if", "(", "TARGET_THUMB1", ")", "emit_insn", "(", "gen_cstoresi_eq0_thumb1", "(", "bval", ",", "bdst", ")", ")", ";", "else", "{", "x", "=", "gen_rtx_EQ", "(", "SImode", ",", "bdst", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "bval", ",", "x", ")", ")", ";", "}", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "pattern", "." ]

[ "arm", "0", "1", "2", "3", "4", "5", "6", "7", "1" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "unsigned", "VReg", ")", "const", "{", "if", "(", "Val", ")", "return", "false", ";", "MIRBuilder", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::S_ENDPGM" ]

[]

[ "<s>", "static", "MachineBasicBlock", "*", "getExitingBlock", "(", "MachineLoop", "*", "L", ")", "{", "if", "(", "MachineBasicBlock", "*", "Latch", "=", "L", "->", "getLoopLatch", "(", ")", ")", "{", "if", "(", "L", "->", "isLoopExiting", "(", "Latch", ")", ")", "return", "Latch", ";", "else", "return", "L", "->", "getExitingBlock", "(", ")", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Return", "the", "first", "block", "of", "this", "region", "'s", "single", "exit", "edge", ",", "if", "existing", "." ]

[ "Hexagon" ]

[]

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

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

[ "R600", "SI" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "TeakRegisterInfo", "::", "getCrossCopyRegClass", "(", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "return", "RC", ";", "}", "</s>" ]

[ "getCrossCopyRegClass", "-", "Returns", "a", "legal", "register", "class", "to", "copy", "a", "register", "in", "the", "specified", "class", "to", "or", "from", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "static", "void", "nvptx_option_override", "(", "void", ")", "{", "init_machine_status", "=", "nvptx_init_machine_status", ";", "if", "(", "!", "global_options_set", ".", "x_flag_toplevel_reorder", ")", "flag_toplevel_reorder", "=", "1", ";", "if", "(", "!", "global_options_set", ".", "x_flag_no_common", ")", "flag_no_common", "=", "1", ";", "flag_var_tracking", "=", "0", ";", "if", "(", "nvptx_optimize", "<", "0", ")", "nvptx_optimize", "=", "optimize", ">", "0", ";", "declared_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "needed_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "declared_libfuncs_htab", "=", "hash_table", "<", "declared_libfunc_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "worker_bcast_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__worker_bcast\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "worker_bcast_sym", ",", "DATA_AREA_SHARED", ")", ";", "worker_bcast_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "worker_red_sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__worker_red\"", ")", ";", "SET_SYMBOL_DATA_AREA", "(", "worker_red_sym", ",", "DATA_AREA_SHARED", ")", ";", "worker_red_align", "=", "GET_MODE_ALIGNMENT", "(", "SImode", ")", "/", "BITS_PER_UNIT", ";", "diagnose_openacc_conflict", "(", "TARGET_GOMP", ",", "\"-mgomp\"", ")", ";", "diagnose_openacc_conflict", "(", "TARGET_SOFT_STACK", ",", "\"-msoft-stack\"", ")", ";", "diagnose_openacc_conflict", "(", "TARGET_UNIFORM_SIMT", ",", "\"-muniform-simt\"", ")", ";", "if", "(", "TARGET_GOMP", ")", "target_flags", "|=", "MASK_SOFT_STACK", "|", "MASK_UNIFORM_SIMT", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "nvptx", "1", "1", "0", "0", "0", "17", "17", "17", "\"__worker_bcast\"", "\"__worker_red\"", "\"-mgomp\"", "\"-msoft-stack\"", "\"-muniform-simt\"" ]

[]

[ "<s>", "static", "void", "mips_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "rtx", "this", ",", "temp1", ",", "temp2", ",", "insn", ",", "fnaddr", ";", "no_new_pseudos", "=", "1", ";", "reload_completed", "=", "1", ";", "reset_block_changes", "(", ")", ";", "if", "(", "TARGET_ABICALLS", ")", "cfun", "->", "machine", "->", "global_pointer", "=", "REGNO", "(", "pic_offset_table_rtx", ")", "=", "TARGET_NEWABI", "?", "15", ":", "GLOBAL_POINTER_REGNUM", ";", "mips_emit_loadgp", "(", ")", ";", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "2", ")", ";", "temp2", "=", "gen_rtx_REG", "(", "Pmode", ",", "3", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", "+", "1", ")", ";", "else", "this", "=", "gen_rtx_REG", "(", "Pmode", ",", "GP_ARG_FIRST", ")", ";", "if", "(", "delta", "!=", "0", ")", "{", "rtx", "offset", "=", "GEN_INT", "(", "delta", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "delta", ")", ")", "{", "emit_move_insn", "(", "temp1", ",", "offset", ")", ";", "offset", "=", "temp1", ";", "}", "emit_insn", "(", "gen_add3_insn", "(", "this", ",", "this", ",", "offset", ")", ")", ";", "}", "if", "(", "vcall_offset", "!=", "0", ")", "{", "rtx", "addr", ";", "emit_move_insn", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this", ")", ")", ";", "addr", "=", "mips_add_offset", "(", "temp2", ",", "temp1", ",", "vcall_offset", ")", ";", "emit_move_insn", "(", "temp1", ",", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "this", ",", "this", ",", "temp1", ")", ")", ";", "}", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "if", "(", "TARGET_MIPS16", "||", "TARGET_ABICALLS", "||", "TARGET_LONG_CALLS", ")", "{", "if", "(", "TARGET_ABICALLS", "&&", "!", "mips_dangerous_for_la25_p", "(", "fnaddr", ")", ")", "temp1", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ";", "mips_load_call_address", "(", "temp1", ",", "fnaddr", ",", "true", ")", ";", "if", "(", "TARGET_ABICALLS", "&&", "REGNO", "(", "temp1", ")", "!=", "PIC_FUNCTION_ADDR_REGNUM", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ",", "temp1", ")", ";", "emit_jump_insn", "(", "gen_indirect_jump", "(", "temp1", ")", ")", ";", "}", "else", "{", "insn", "=", "emit_call_insn", "(", "gen_sibcall_internal", "(", "fnaddr", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "}", "insn", "=", "get_insns", "(", ")", ";", "insn_locators_initialize", "(", ")", ";", "split_all_insns_noflow", "(", ")", ";", "if", "(", "TARGET_MIPS16", ")", "mips16_lay_out_constants", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "reload_completed", "=", "0", ";", "no_new_pseudos", "=", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_OUTPUT_MI_THUNK", ".", "Generate", "rtl", "rather", "than", "asm", "text", "in", "order", "to", "avoid", "duplicating", "too", "much", "logic", "from", "elsewhere", "." ]

[ "mips", "1", "1", "15", "2", "3", "1", "0", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "LaneBitmask", "HexagonExpandCondsets", "::", "getLaneMask", "(", "Register", "Reg", ",", "unsigned", "Sub", ")", "{", "assert", "(", "Reg", ".", "isVirtual", "(", ")", ")", ";", "return", "Sub", "!=", "0", "?", "TRI", "->", "getSubRegIndexLaneMask", "(", "Sub", ")", ":", "MRI", "->", "getMaxLaneMaskForVReg", "(", "Reg", ")", ";", "}", "</s>" ]

[ "Returns", "the", "combination", "of", "all", "lane", "masks", "of", "register", "in", "this", "class", "." ]

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

[]

[ "<s>", "static", "rtx", "function_arg_union_value", "(", "int", "size", ",", "machine_mode", "mode", ",", "int", "slotno", ",", "int", "regno", ")", "{", "unsigned", "int", "nwords", ";", "if", "(", "size", "<=", "0", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "if", "(", "slotno", "==", "SPARC_INT_ARG_MAX", "-", "1", ")", "nwords", "=", "1", ";", "else", "nwords", "=", "CEIL_NWORDS", "(", "size", ")", ";", "rtx", "regs", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "nwords", ")", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "nwords", ";", "i", "++", ")", "XVECEXP", "(", "regs", ",", "0", ",", "i", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "word_mode", ",", "regno", "+", "i", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", "*", "i", ")", ")", ";", "return", "regs", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "conventions", "of", "the", "64-bit", "ABI", "for", "passing", "and", "returning", "unions", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "SIZE", "is", "the", "size", "in", "bytes", "of", "the", "union", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "REGNO", "is", "the", "hard", "register", "the", "union", "will", "be", "passed", "in", "." ]

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

[]

[ "<s>", "void", "JVMPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "JVM", "JVM" ]

[]

[ "<s>", "static", "int", "loongarch_symbol_insns", "(", "enum", "loongarch_symbol_type", "type", ",", "machine_mode", "mode", ")", "{", "switch", "(", "type", ")", "{", "case", "SYMBOL_GOT_DISP", ":", "if", "(", "mode", "!=", "MAX_MACHINE_MODE", ")", "return", "0", ";", "return", "3", ";", "case", "SYMBOL_TLSGD", ":", "case", "SYMBOL_TLSLDM", ":", "return", "1", ";", "case", "SYMBOL_TLS", ":", "return", "0", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "instructions", "necessary", "to", "reference", "a", "symbol", "." ]

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

[]

[ "<s>", "bool", "AMDGPUTTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "Argument", "*", "A", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "isArgPassedInSGPR", "(", "A", ")", ";", "if", "(", "const", "LoadInst", "*", "Load", "=", "dyn_cast", "<", "LoadInst", ">", "(", "V", ")", ")", "return", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ";", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "V", ")", "||", "isa", "<", "AtomicCmpXchgInst", ">", "(", "V", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "return", "isIntrinsicSourceOfDivergence", "(", "Intrinsic", ")", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "V", ")", "||", "isa", "<", "InvokeInst", ">", "(", "V", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "V", "is", "a", "source", "of", "divergence", "." ]

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

[]

[ "<s>", "bool", "AVRAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AVR", "::", "fixup_7_pcrel", ":", "case", "AVR", "::", "fixup_13_pcrel", ":", "case", "AVR", "::", "fixup_call", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::fixup_7_pcrel", "AVR::fixup_13_pcrel", "AVR::fixup_call" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "bool", "isThisReturn", ",", "SDValue", "ThisVal", ")", "const", "{", "CCAssignFn", "*", "RetCC", "=", "CallConv", "==", "CallingConv", "::", "WebKit_JS", "?", "RetCC_AArch64_WebKit_JS", ":", "RetCC_AArch64_AAPCS", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "VA", "=", "RVLocs", "[", "i", "]", ";", "if", "(", "i", "==", "0", "&&", "isThisReturn", ")", "{", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", "&&", "\"unexpected return calling convention register assignment\"", ")", ";", "InVals", ".", "push_back", "(", "ThisVal", ")", ";", "continue", ";", "}", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "2", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "ISD::InputArg", "AArch64", "AArch64", "16", "0", "0", "MVT::i64", "\"unexpected return calling convention register assignment\"", "1", "2", "\"Unknown loc info!\"", "ISD::BITCAST" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "SystemZTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'d'", ":", "case", "'f'", ":", "case", "'r'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "case", "'m'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "return", "C_Other", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1", "0" ]

[]

[ "<s>", "static", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "splitVector", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "dl", ")", "{", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "unsigned", "NumElems", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "SizeInBits", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "assert", "(", "(", "NumElems", "%", "2", ")", "==", "0", "&&", "(", "SizeInBits", "%", "2", ")", "==", "0", "&&", "\"Can't split odd sized vector\"", ")", ";", "SDValue", "Lo", "=", "extractSubVector", "(", "Op", ",", "0", ",", "DAG", ",", "dl", ",", "SizeInBits", "/", "2", ")", ";", "if", "(", "DAG", ".", "isSplatValue", "(", "Op", ",", "false", ")", ")", "return", "std", "::", "make_pair", "(", "Lo", ",", "Lo", ")", ";", "SDValue", "Hi", "=", "extractSubVector", "(", "Op", ",", "NumElems", "/", "2", ",", "DAG", ",", "dl", ",", "SizeInBits", "/", "2", ")", ";", "return", "std", "::", "make_pair", "(", "Lo", ",", "Hi", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "value", "into", "two", "parts", "of", "types", "LoVT", "and", "HiVT", "." ]

[ "X86", "2", "0", "2", "0", "\"Can't split odd sized vector\"", "0", "2", "2", "2" ]

[]

[ "<s>", "bool", "X86AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "static", "const", "uint8_t", "Nops", "[", "10", "]", "[", "10", "]", "=", "{", "{", "0x90", "}", ",", "{", "0x66", ",", "0x90", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x40", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x80", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x2e", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "}", ";", "if", "(", "CPU", "==", "\"generic\"", "||", "CPU", "==", "\"i386\"", "||", "CPU", "==", "\"i486\"", "||", "CPU", "==", "\"i586\"", "||", "CPU", "==", "\"pentium\"", "||", "CPU", "==", "\"pentium-mmx\"", "||", "CPU", "==", "\"geode\"", ")", "{", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "++", "i", ")", "OW", "->", "Write8", "(", "0x90", ")", ";", "return", "true", ";", "}", "do", "{", "const", "uint8_t", "ThisNopLength", "=", "(", "uint8_t", ")", "std", "::", "min", "(", "Count", ",", "(", "uint64_t", ")", "15", ")", ";", "const", "uint8_t", "Prefixes", "=", "ThisNopLength", "<=", "10", "?", "0", ":", "ThisNopLength", "-", "10", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Prefixes", ";", "i", "++", ")", "OW", "->", "Write8", "(", "0x66", ")", ";", "const", "uint8_t", "Rest", "=", "ThisNopLength", "-", "Prefixes", ";", "for", "(", "uint8_t", "i", "=", "0", ";", "i", "<", "Rest", ";", "i", "++", ")", "OW", "->", "Write8", "(", "Nops", "[", "Rest", "-", "1", "]", "[", "i", "]", ")", ";", "Count", "-=", "ThisNopLength", ";", "}", "while", "(", "Count", "!=", "0", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "10", "10", "0x90", "0x66", "0x90", "0x0f", "0x1f", "0x00", "0x0f", "0x1f", "0x40", "0x00", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x0f", "0x1f", "0x80", "0x00", "0x00", "0x00", "0x00", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x2e", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "\"generic\"", "\"i386\"", "\"i486\"", "\"i586\"", "\"pentium\"", "\"pentium-mmx\"", "\"geode\"", "0", "0x90", "15", "10", "0", "10", "0", "0x66", "0", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "SNESTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "SNESISD", "::", "name", ":", "\\", "return", "#", "name", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE", "(", "RET_FLAG", ")", ";", "NODE", "(", "RETI_FLAG", ")", ";", "NODE", "(", "CALL", ")", ";", "NODE", "(", "WRAPPER", ")", ";", "NODE", "(", "LSL", ")", ";", "NODE", "(", "LSR", ")", ";", "NODE", "(", "ROL", ")", ";", "NODE", "(", "ROR", ")", ";", "NODE", "(", "ASR", ")", ";", "NODE", "(", "LSLLOOP", ")", ";", "NODE", "(", "LSRLOOP", ")", ";", "NODE", "(", "ASRLOOP", ")", ";", "NODE", "(", "BRCOND", ")", ";", "NODE", "(", "CMP", ")", ";", "NODE", "(", "CMPC", ")", ";", "NODE", "(", "TST", ")", ";", "NODE", "(", "SELECT_CC", ")", ";", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "SNES", "SNES", "SNESISD::name" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "if", "(", "!", "MI", "->", "mayLoad", "(", ")", "&&", "!", "MI", "->", "mayStore", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "16", "*", "20", ";", "Offset", "+=", "MFI", ".", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "AArch64", "::", "FP", ",", "FPOffset", ")", ")", "return", "false", ";", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "AArch64", "::", "SP", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "\"Instr doesn't have FrameIndex operand!\"", "AArch64", "16", "20", "128", "AArch64::FP", "AArch64::SP" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_binop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "tree", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ";", "tree", "arg1", "=", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ";", "rtx", "op0", "=", "expand_normal", "(", "arg0", ")", ";", "rtx", "op1", "=", "expand_normal", "(", "arg1", ")", ";", "machine_mode", "tmode", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "machine_mode", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "mode", ";", "if", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", "op0", "=", "safe_vector_operand", "(", "op0", ",", "mode0", ")", ";", "if", "(", "VECTOR_MODE_P", "(", "mode1", ")", ")", "op1", "=", "safe_vector_operand", "(", "op1", ",", "mode1", ")", ";", "if", "(", "optimize", "||", "!", "target", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "if", "(", "GET_MODE", "(", "op1", ")", "==", "SImode", "&&", "mode1", "==", "TImode", ")", "{", "rtx", "x", "=", "gen_reg_rtx", "(", "V4SImode", ")", ";", "emit_insn", "(", "gen_sse2_loadd", "(", "x", ",", "op1", ")", ")", ";", "op1", "=", "gen_lowpart", "(", "TImode", ",", "x", ")", ";", "}", "if", "(", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "!", "insn_data", "[", "icode", "]", ".", "operand", "[", "2", "]", ".", "predicate", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Subroutine", "of", "ix86_expand_builtin", "to", "take", "care", "of", "binop", "insns", "." ]

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

[]

[ "<s>", "unsigned", "OR1KRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "OR1K", "::", "R9", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "OR1K", "OR1K", "OR1K::R9" ]

[]

[ "<s>", "unsigned", "R600InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "{", "return", "0", ";", "}", "--", "I", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "R600", "::", "JUMP_COND", ":", "{", "MachineInstr", "*", "predSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "I", ")", ";", "clearFlag", "(", "*", "predSet", ",", "0", ",", "MO_FLAG_PUSH", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "break", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "R600", "::", "CF_ALU_PUSH_BEFORE", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "R600", "::", "CF_ALU", ")", ")", ";", "break", ";", "}", "case", "R600", "::", "JUMP", ":", "I", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "{", "return", "1", ";", "}", "--", "I", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "1", ";", "case", "R600", "::", "JUMP_COND", ":", "{", "MachineInstr", "*", "predSet", "=", "findFirstPredicateSetterFrom", "(", "MBB", ",", "I", ")", ";", "clearFlag", "(", "*", "predSet", ",", "0", ",", "MO_FLAG_PUSH", ")", ";", "I", "->", "eraseFromParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "CfAlu", "=", "FindLastAluClause", "(", "MBB", ")", ";", "if", "(", "CfAlu", "==", "MBB", ".", "end", "(", ")", ")", "break", ";", "assert", "(", "CfAlu", "->", "getOpcode", "(", ")", "==", "R600", "::", "CF_ALU_PUSH_BEFORE", ")", ";", "CfAlu", "->", "setDesc", "(", "get", "(", "R600", "::", "CF_ALU", ")", ")", ";", "break", ";", "}", "case", "R600", "::", "JUMP", ":", "I", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "return", "2", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "AMDGPU", "R600", "\"code size not handled\"", "0", "0", "R600::JUMP_COND", "0", "R600::CF_ALU_PUSH_BEFORE", "R600::CF_ALU", "R600::JUMP", "1", "1", "R600::JUMP_COND", "0", "R600::CF_ALU_PUSH_BEFORE", "R600::CF_ALU", "R600::JUMP", "2" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_ALL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "if", "(", "isPPC64", "(", ")", ")", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "G8RCRegClass", ")", ";", "else", "CriticalPathRCs", ".", "push_back", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "return", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";", "}", "</s>" ]

[ "True", "if", "the", "subtarget", "should", "run", "a", "scheduler", "after", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "int", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "bool", "invertJump", "=", "(", "!", "Cond", ".", "empty", "(", ")", "&&", "Cond", "[", "0", "]", ".", "isImm", "(", ")", "&&", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", "==", "0", ")", ")", ";", "MI", "->", "setDesc", "(", "get", "(", "getMatchingCondBranchOpcode", "(", "Opc", ",", "invertJump", ")", ")", ")", ";", "MI", "->", "addOperand", "(", "MI", "->", "getOperand", "(", "MI", "->", "getNumOperands", "(", ")", "-", "1", ")", ")", ";", "int", "oper", ";", "for", "(", "oper", "=", "MI", "->", "getNumOperands", "(", ")", "-", "3", ";", "oper", ">=", "0", ";", "--", "oper", ")", "{", "MachineOperand", "MO", "=", "MI", "->", "getOperand", "(", "oper", ")", ";", "if", "(", "(", "MO", ".", "isReg", "(", ")", "&&", "!", "MO", ".", "isUse", "(", ")", "&&", "!", "MO", ".", "isImplicit", "(", ")", ")", ")", "{", "break", ";", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "MI", "->", "getOperand", "(", "oper", "+", "1", ")", ".", "ChangeToRegister", "(", "MO", ".", "getReg", "(", ")", ",", "MO", ".", "isDef", "(", ")", ",", "MO", ".", "isImplicit", "(", ")", ",", "MO", ".", "isKill", "(", ")", ",", "MO", ".", "isDead", "(", ")", ",", "MO", ".", "isUndef", "(", ")", ",", "MO", ".", "isDebug", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "MI", "->", "getOperand", "(", "oper", "+", "1", ")", ".", "ChangeToImmediate", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unexpected operand type\"", ")", ";", "}", "}", "int", "regPos", "=", "invertJump", "?", "1", ":", "0", ";", "MachineOperand", "PredMO", "=", "Cond", "[", "regPos", "]", ";", "MI", "->", "getOperand", "(", "oper", "+", "1", ")", ".", "ChangeToRegister", "(", "PredMO", ".", "getReg", "(", ")", ",", "PredMO", ".", "isDef", "(", ")", ",", "PredMO", ".", "isImplicit", "(", ")", ",", "PredMO", ".", "isKill", "(", ")", ",", "PredMO", ".", "isDead", "(", ")", ",", "PredMO", ".", "isUndef", "(", ")", ",", "PredMO", ".", "isDebug", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "Hexagon", "Hexagon", "\"Expected predicable instruction\"", "0", "0", "0", "1", "3", "0", "1", "1", "\"Unexpected operand type\"", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "get231Opcode", "(", ")", "const", "{", "return", "Opcodes", "[", "Form231", "]", ";", "}", "</s>" ]

[ "Returns", "the", "231", "form", "of", "FMA", "opcode", "." ]

[ "X86" ]

[]

[ "<s>", "void", "BlackfinInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "if", "(", "inClass", "(", "BF", "::", "DPRegClass", ",", "DestReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "LOAD32fi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "D16RegClass", ",", "DestReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "LOAD16fi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "if", "(", "inClass", "(", "BF", "::", "AnyCCRegClass", ",", "DestReg", ",", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "BF", "::", "LOAD8fi", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "llvm_unreachable", "(", "\"Cannot load regclass from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Blackfin", "BF::DPRegClass", "BF::LOAD32fi", "0", "BF::D16RegClass", "BF::LOAD16fi", "0", "BF::AnyCCRegClass", "BF::LOAD8fi", "0", "\"Cannot load regclass from stack slot\"" ]

[]