Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "CCAssignFn", "*", "X86FastISel", "::", "CCAssignFnForCall", "(", "unsigned", "CC", ",", "bool", "isTaillCall", ")", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "isTargetWin64", "(", ")", ")", "return", "CC_X86_Win64_C", ";", "else", "return", "CC_X86_64_C", ";", "}", "if", "(", "CC", "==", "CallingConv", "::", "X86_FastCall", ")", "return", "CC_X86_32_FastCall", ";", "else", "if", "(", "CC", "==", "CallingConv", "::", "Fast", ")", "return", "CC_X86_32_FastCC", ";", "else", "return", "CC_X86_32_C", ";", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

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

[]

[ "<s>", "bool", "ix86_operands_ok_for_move_multiple", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "offval_1", ",", "offval_2", ",", "msize", ";", "rtx", "mem_1", ",", "mem_2", ",", "reg_1", ",", "reg_2", ",", "base_1", ",", "base_2", ",", "offset_1", ",", "offset_2", ";", "if", "(", "load", ")", "{", "mem_1", "=", "operands", "[", "1", "]", ";", "mem_2", "=", "operands", "[", "3", "]", ";", "reg_1", "=", "operands", "[", "0", "]", ";", "reg_2", "=", "operands", "[", "2", "]", ";", "}", "else", "{", "mem_1", "=", "operands", "[", "0", "]", ";", "mem_2", "=", "operands", "[", "2", "]", ";", "reg_1", "=", "operands", "[", "1", "]", ";", "reg_2", "=", "operands", "[", "3", "]", ";", "}", "gcc_assert", "(", "REG_P", "(", "reg_1", ")", "&&", "REG_P", "(", "reg_2", ")", ")", ";", "if", "(", "REGNO", "(", "reg_1", ")", "!=", "REGNO", "(", "reg_2", ")", ")", "return", "false", ";", "if", "(", "!", "extract_base_offset_in_addr", "(", "mem_1", ",", "&", "base_1", ",", "&", "offset_1", ")", ")", "return", "false", ";", "if", "(", "!", "extract_base_offset_in_addr", "(", "mem_2", ",", "&", "base_2", ",", "&", "offset_2", ")", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "base_1", ",", "base_2", ")", ")", "return", "false", ";", "offval_1", "=", "INTVAL", "(", "offset_1", ")", ";", "offval_2", "=", "INTVAL", "(", "offset_2", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "offval_1", "+", "msize", "!=", "offval_2", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", ",", "check", "if", "we", "can", "merge", "them", "into", "move", "multiple", ".", "LOAD", "is", "true", "if", "they", "are", "load", "instructions", ".", "MODE", "is", "the", "mode", "of", "memory", "operands", "." ]

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

[]

[ "<s>", "static", "bool", "riscv_can_eliminate", "(", "const", "int", "from", "ATTRIBUTE_UNUSED", ",", "const", "int", "to", ")", "{", "return", "(", "to", "==", "HARD_FRAME_POINTER_REGNUM", "||", "to", "==", "STACK_POINTER_REGNUM", ")", ";", "}", "</s>" ]

[ "Make", "sure", "that", "we", "'re", "not", "trying", "to", "eliminate", "to", "the", "wrong", "hard", "frame", "pointer", "." ]

[ "riscv" ]

[]

[ "<s>", "LLT", "SITargetLowering", "::", "getPreferredShiftAmountTy", "(", "LLT", "Ty", ")", "const", "{", "return", "(", "Ty", ".", "getScalarSizeInBits", "(", ")", "<=", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "?", "Ty", ".", "changeElementSize", "(", "16", ")", ":", "Ty", ".", "changeElementSize", "(", "32", ")", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "type", "to", "use", "for", "a", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "is", "ShiftValueTy", "." ]

[ "AMDGPU", "SI", "16", "16", "32" ]

[]

[ "<s>", "const", "MCS51Subtarget", "*", "MCS51TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", ")", "const", "{", "return", "&", "SubTarget", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx", "gen_load_const_gp", "(", "rtx", "reg", ")", "{", "return", "PMODE_INSN", "(", "gen_load_const_gp", ",", "(", "reg", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "instruction", "that", "copies", "$", "gp", "into", "register", "REG", ".", "We", "want", "GCC", "to", "treat", "the", "register", "'s", "value", "as", "constant", ",", "so", "that", "its", "value", "can", "be", "rematerialized", "on", "demand", "." ]

[ "mips" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "8", "==", "0", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "SystemZ", "8", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Fix WWM Liveness\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Fix WWM Liveness\"" ]

[]

[ "<s>", "static", "bool", "or1k_return_in_memory", "(", "const_tree", "type", ",", "const_tree", ")", "{", "const", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "(", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "}", "</s>" ]

[ "worker", "function", "for", "TARGET_RETURN_IN_MEMORY", ".", "Returns", "true", "if", "the", "argument", "of", "TYPE", "should", "be", "returned", "in", "memory", ".", "On", "OpenRISC", "this", "is", "any", "value", "larger", "than", "64-bits", "." ]

[ "or1k", "1", "2" ]

[]

[ "<s>", "Liveness", "(", "MachineRegisterInfo", "&", "mri", ",", "const", "DataFlowGraph", "&", "g", ")", ":", "DFG", "(", "g", ")", ",", "TRI", "(", "g", ".", "getTRI", "(", ")", ")", ",", "PRI", "(", "g", ".", "getPRI", "(", ")", ")", ",", "MDT", "(", "g", ".", "getDT", "(", ")", ")", ",", "MDF", "(", "g", ".", "getDF", "(", ")", ")", ",", "LiveMap", "(", "g", ".", "getPRI", "(", ")", ")", ",", "NoRegs", "(", "g", ".", "getPRI", "(", ")", ")", "{", "}", "</s>" ]

[ "During", "our", "initial", "pass", "over", "the", "program", ",", "we", "determine", "that", "things", "are", "either", "alive", "or", "maybe", "alive", ".", "More", "..." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "ARMConstantPoolValue", "*", "APV", ")", "{", "return", "APV", "->", "isGlobalValue", "(", ")", "||", "APV", "->", "isBlockAddress", "(", ")", "||", "APV", "->", "isLSDA", "(", ")", "||", "APV", "->", "isPromotedGlobal", "(", ")", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "if", "(", "IsThumb", ")", "EmitThumbMappingSymbol", "(", ")", ";", "else", "EmitARMMappingSymbol", "(", ")", ";", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "virtual", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "{", "visit", "(", "F", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "rtx", "ix86_build_signbit_mask", "(", "machine_mode", "mode", ",", "bool", "vect", ",", "bool", "invert", ")", "{", "machine_mode", "vec_mode", ",", "imode", ";", "wide_int", "w", ";", "rtx", "mask", ",", "v", ";", "switch", "(", "mode", ")", "{", "case", "E_V8HFmode", ":", "case", "E_V16HFmode", ":", "case", "E_V32HFmode", ":", "vec_mode", "=", "mode", ";", "imode", "=", "HImode", ";", "break", ";", "case", "E_V16SImode", ":", "case", "E_V16SFmode", ":", "case", "E_V8SImode", ":", "case", "E_V4SImode", ":", "case", "E_V8SFmode", ":", "case", "E_V4SFmode", ":", "case", "E_V2SFmode", ":", "case", "E_V2SImode", ":", "vec_mode", "=", "mode", ";", "imode", "=", "SImode", ";", "break", ";", "case", "E_V8DImode", ":", "case", "E_V4DImode", ":", "case", "E_V2DImode", ":", "case", "E_V8DFmode", ":", "case", "E_V4DFmode", ":", "case", "E_V2DFmode", ":", "vec_mode", "=", "mode", ";", "imode", "=", "DImode", ";", "break", ";", "case", "E_TImode", ":", "case", "E_TFmode", ":", "vec_mode", "=", "VOIDmode", ";", "imode", "=", "TImode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "w", "=", "wi", "::", "set_bit_in_zero", "(", "GET_MODE_BITSIZE", "(", "inner_mode", ")", "-", "1", ",", "GET_MODE_BITSIZE", "(", "inner_mode", ")", ")", ";", "if", "(", "invert", ")", "w", "=", "wi", "::", "bit_not", "(", "w", ")", ";", "mask", "=", "immed_wide_int_const", "(", "w", ",", "imode", ")", ";", "mask", "=", "gen_lowpart", "(", "inner_mode", ",", "mask", ")", ";", "if", "(", "vec_mode", "==", "VOIDmode", ")", "return", "force_reg", "(", "inner_mode", ",", "mask", ")", ";", "v", "=", "ix86_build_const_vector", "(", "vec_mode", ",", "vect", ",", "mask", ")", ";", "return", "force_reg", "(", "vec_mode", ",", "v", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "ix86_expand_fp_absneg_operator", "and", "copysign", "expanders", ".", "Create", "a", "mask", "for", "the", "sign", "bit", "in", "MODE", "for", "an", "SSE", "register", ".", "If", "VECT", "is", "true", ",", "then", "replicate", "the", "mask", "for", "all", "elements", "of", "the", "vector", "register", ".", "If", "INVERT", "is", "true", ",", "then", "create", "a", "mask", "excluding", "the", "sign", "bit", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "HexagonSplitConst32AndConst64", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "auto", "&", "HST", "=", "Fn", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HTM", "=", "static_cast", "<", "const", "HexagonTargetMachine", "&", ">", "(", "Fn", ".", "getTarget", "(", ")", ")", ";", "auto", "&", "TLOF", "=", "*", "HTM", ".", "getObjFileLowering", "(", ")", ";", "if", "(", "HST", ".", "useSmallData", "(", ")", "&&", "TLOF", ".", "isSmallDataEnabled", "(", "HTM", ")", ")", "return", "false", ";", "const", "TargetInstrInfo", "*", "TII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "B", ":", "Fn", ")", "{", "for", "(", "auto", "I", "=", "B", ".", "begin", "(", ")", ",", "E", "=", "B", ".", "end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "++", "I", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "Hexagon", "::", "CONST32", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "uint64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestReg", ")", ".", "addImm", "(", "ImmValue", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "else", "if", "(", "Opc", "==", "Hexagon", "::", "CONST64", ")", "{", "unsigned", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "int64_t", "ImmValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "DestLo", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "isub_lo", ")", ";", "unsigned", "DestHi", "=", "TRI", "->", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "isub_hi", ")", ";", "int32_t", "LowWord", "=", "(", "ImmValue", "&", "0xFFFFFFFF", ")", ";", "int32_t", "HighWord", "=", "(", "ImmValue", ">>", "32", ")", "&", "0xFFFFFFFF", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestLo", ")", ".", "addImm", "(", "LowWord", ")", ";", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "Hexagon", "::", "A2_tfrsi", ")", ",", "DestHi", ")", ".", "addImm", "(", "HighWord", ")", ";", "B", ".", "erase", "(", "&", "MI", ")", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::CONST32", "0", "1", "Hexagon::A2_tfrsi", "Hexagon::CONST64", "0", "1", "Hexagon::isub_lo", "Hexagon::isub_hi", "0xFFFFFFFF", "32", "0xFFFFFFFF", "Hexagon::A2_tfrsi", "Hexagon::A2_tfrsi" ]

[]

[ "<s>", "static", "void", "loongarch_print_operand_punctuation", "(", "FILE", "*", "file", ",", "int", "ch", ")", "{", "switch", "(", "ch", ")", "{", "case", "'.'", ":", "fputs", "(", "reg_names", "[", "GP_REG_FIRST", "+", "0", "]", ",", "file", ")", ";", "break", ";", "case", "'$'", ":", "fputs", "(", "reg_names", "[", "STACK_POINTER_REGNUM", "]", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Print", "the", "text", "for", "PRINT_OPERAND", "punctation", "character", "CH", "to", "FILE", ".", "The", "punctuation", "characters", "are", ":", "'", ".", "'", "Print", "the", "name", "of", "the", "register", "with", "a", "hard-wired", "zero", "(", "zero", "or", "$", "r0", ")", ".", "'", "$", "'", "Print", "the", "name", "of", "the", "stack", "pointer", "register", "(", "sp", "or", "$", "r3", ")", ".", "See", "also", "loongarch_init_print_operand_punct", "." ]

[ "loongarch", "0" ]

[]

[ "<s>", "unsigned", "PPCTTI", "::", "getIntImmCost", "(", "Intrinsic", "::", "ID", "IID", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "TargetTransformInfo", "::", "getIntImmCost", "(", "IID", ",", "Idx", ",", "Imm", ",", "Ty", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "switch", "(", "IID", ")", "{", "default", ":", "return", "TCC_Free", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "if", "(", "(", "Idx", "==", "1", ")", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TCC_Free", ";", "break", ";", "}", "return", "PPCTTI", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "PowerPC", "PPC", "Intrinsic::ID", "PPC", "0", "0U", "Intrinsic::sadd_with_overflow", "Intrinsic::uadd_with_overflow", "Intrinsic::ssub_with_overflow", "Intrinsic::usub_with_overflow", "1", "64", "16", "PPC" ]

[]

[ "<s>", "std", "::", "vector", "<", "const", "SUnit", "*", ">", "GCNMinRegScheduler", "::", "schedule", "(", "ArrayRef", "<", "const", "SUnit", "*", ">", "TopRoots", ",", "const", "ScheduleDAG", "&", "DAG", ")", "{", "const", "auto", "&", "SUnits", "=", "DAG", ".", "SUnits", ";", "std", "::", "vector", "<", "const", "SUnit", "*", ">", "Schedule", ";", "Schedule", ".", "reserve", "(", "SUnits", ".", "size", "(", ")", ")", ";", "initNumPreds", "(", "SUnits", ")", ";", "int", "StepNo", "=", "0", ";", "for", "(", "auto", "SU", ":", "TopRoots", ")", "{", "RQ", ".", "push_back", "(", "*", "new", "(", "Alloc", ".", "Allocate", "(", ")", ")", "Candidate", "(", "SU", ",", "StepNo", ")", ")", ";", "}", "releaseSuccessors", "(", "&", "DAG", ".", "EntrySU", ",", "StepNo", ")", ";", "while", "(", "!", "RQ", ".", "empty", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n=== Picking candidate, Step = \"", "<<", "StepNo", "<<", "\"\\n\"", "\"Ready queue:\"", ";", "for", "(", "auto", "&", "C", ":", "RQ", ")", "dbgs", "(", ")", "<<", "' '", "<<", "C", ".", "SU", "->", "NodeNum", "<<", "\"(P\"", "<<", "C", ".", "Priority", "<<", "')'", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", ")", ";", "auto", "C", "=", "pickCandidate", "(", ")", ";", "assert", "(", "C", ")", ";", "RQ", ".", "remove", "(", "*", "C", ")", ";", "auto", "SU", "=", "C", "->", "SU", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selected \"", ";", "DAG", ".", "dumpNode", "(", "*", "SU", ")", ")", ";", "releaseSuccessors", "(", "SU", ",", "StepNo", ")", ";", "Schedule", ".", "push_back", "(", "SU", ")", ";", "setIsScheduled", "(", "SU", ")", ";", "if", "(", "getReadySuccessors", "(", "SU", ")", "==", "0", ")", "bumpPredsPriority", "(", "SU", ",", "StepNo", ")", ";", "++", "StepNo", ";", "}", "assert", "(", "SUnits", ".", "size", "(", ")", "==", "Schedule", ".", "size", "(", ")", ")", ";", "return", "Schedule", ";", "}", "</s>" ]

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

[ "AMDGPU", "0", "\"\\n=== Picking candidate, Step = \"", "\"\\n\"", "\"Ready queue:\"", "\"(P\"", "\"Selected \"", "0" ]

[]

[ "<s>", "static", "rtx", "function_arg_record_value", "(", "tree", "type", ",", "enum", "machine_mode", "mode", ",", "int", "slotno", ",", "int", "named", ",", "int", "regbase", ")", "{", "HOST_WIDE_INT", "typesize", "=", "int_size_in_bytes", "(", "type", ")", ";", "struct", "function_arg_record_value_parms", "parms", ";", "unsigned", "int", "nregs", ";", "parms", ".", "ret", "=", "NULL_RTX", ";", "parms", ".", "slotno", "=", "slotno", ";", "parms", ".", "named", "=", "named", ";", "parms", ".", "regbase", "=", "regbase", ";", "parms", ".", "stack", "=", "0", ";", "parms", ".", "nregs", "=", "0", ";", "parms", ".", "intoffset", "=", "0", ";", "function_arg_record_value_1", "(", "type", ",", "0", ",", "&", "parms", ",", "false", ")", ";", "if", "(", "parms", ".", "intoffset", "!=", "-", "1", ")", "{", "unsigned", "int", "startbit", ",", "endbit", ";", "int", "intslots", ",", "this_slotno", ";", "startbit", "=", "parms", ".", "intoffset", "&", "-", "BITS_PER_WORD", ";", "endbit", "=", "(", "typesize", "*", "BITS_PER_UNIT", "+", "BITS_PER_WORD", "-", "1", ")", "&", "-", "BITS_PER_WORD", ";", "intslots", "=", "(", "endbit", "-", "startbit", ")", "/", "BITS_PER_WORD", ";", "this_slotno", "=", "slotno", "+", "parms", ".", "intoffset", "/", "BITS_PER_WORD", ";", "if", "(", "intslots", ">", "0", "&&", "intslots", ">", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", "{", "intslots", "=", "MAX", "(", "0", ",", "SPARC_INT_ARG_MAX", "-", "this_slotno", ")", ";", "parms", ".", "stack", "=", "1", ";", "}", "parms", ".", "nregs", "+=", "intslots", ";", "}", "nregs", "=", "parms", ".", "nregs", ";", "if", "(", "nregs", "==", "0", ")", "{", "if", "(", "typesize", "<=", "0", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "regbase", ")", ";", "}", "else", "{", "nregs", "=", "(", "typesize", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "}", "if", "(", "nregs", "+", "slotno", ">", "SPARC_INT_ARG_MAX", ")", "nregs", "=", "SPARC_INT_ARG_MAX", "-", "slotno", ";", "}", "gcc_assert", "(", "nregs", "!=", "0", ")", ";", "parms", ".", "ret", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "parms", ".", "stack", "+", "nregs", ")", ")", ";", "if", "(", "parms", ".", "stack", ")", "XVECEXP", "(", "parms", ".", "ret", ",", "0", ",", "0", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "NULL_RTX", ",", "const0_rtx", ")", ";", "parms", ".", "nregs", "=", "0", ";", "parms", ".", "intoffset", "=", "0", ";", "function_arg_record_value_2", "(", "type", ",", "0", ",", "&", "parms", ",", "false", ")", ";", "function_arg_record_value_3", "(", "typesize", "*", "BITS_PER_UNIT", ",", "&", "parms", ")", ";", "gcc_assert", "(", "parms", ".", "nregs", "==", "nregs", ")", ";", "return", "parms", ".", "ret", ";", "}", "</s>" ]

[ "Used", "by", "function_arg", "and", "sparc_function_value_1", "to", "implement", "the", "complex", "conventions", "of", "the", "64-bit", "ABI", "for", "passing", "and", "returning", "structures", ".", "Return", "an", "expression", "valid", "as", "a", "return", "value", "for", "the", "FUNCTION_ARG", "and", "TARGET_FUNCTION_VALUE", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "SLOTNO", "is", "the", "index", "number", "of", "the", "argument", "'s", "slot", "in", "the", "parameter", "array", ".", "NAMED", "is", "true", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", ".", "REGBASE", "is", "the", "regno", "of", "the", "base", "register", "for", "the", "parameter", "array", "." ]

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

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "!", "TargetSupported", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "SelectRet", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "virtual", "const", "AlphaSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha" ]

[]

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

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

[ "CellSPU", "SPU" ]

[]

[ "<s>", "void", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", "&&", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "}", "</s>" ]

[ "Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "." ]

[ "visium", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "cr16_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", "Nonzero", "if", "X", "is", "a", "legitimate", "constant", "for", "an", "immediate", "operand", "on", "the", "target", "machine", ".", "You", "can", "assume", "that", "X", "satisfies", "CONSTANT_P", ".", "In", "cr16c", "treat", "legitimize", "float", "constant", "as", "an", "immediate", "operand", "." ]

[ "cr16", "1" ]

[]

[ "<s>", "static", "void", "init_float128_ibm", "(", "machine_mode", "mode", ")", "{", "if", "(", "!", "TARGET_XL_COMPAT", ")", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "\"__gcc_qadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "\"__gcc_qsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "\"__gcc_qmul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "\"__gcc_qdiv\"", ")", ";", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "set_optab_libfunc", "(", "neg_optab", ",", "mode", ",", "\"__gcc_qneg\"", ")", ";", "set_optab_libfunc", "(", "eq_optab", ",", "mode", ",", "\"__gcc_qeq\"", ")", ";", "set_optab_libfunc", "(", "ne_optab", ",", "mode", ",", "\"__gcc_qne\"", ")", ";", "set_optab_libfunc", "(", "gt_optab", ",", "mode", ",", "\"__gcc_qgt\"", ")", ";", "set_optab_libfunc", "(", "ge_optab", ",", "mode", ",", "\"__gcc_qge\"", ")", ";", "set_optab_libfunc", "(", "lt_optab", ",", "mode", ",", "\"__gcc_qlt\"", ")", ";", "set_optab_libfunc", "(", "le_optab", ",", "mode", ",", "\"__gcc_qle\"", ")", ";", "set_optab_libfunc", "(", "unord_optab", ",", "mode", ",", "\"__gcc_qunord\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "SFmode", ",", "\"__gcc_stoq\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "DFmode", ",", "\"__gcc_dtoq\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "mode", ",", "\"__gcc_qtos\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DFmode", ",", "mode", ",", "\"__gcc_qtod\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "mode", ",", "\"__gcc_qtoi\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "SImode", ",", "mode", ",", "\"__gcc_qtou\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "SImode", ",", "\"__gcc_itoq\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "SImode", ",", "\"__gcc_utoq\"", ")", ";", "}", "}", "else", "{", "set_optab_libfunc", "(", "add_optab", ",", "mode", ",", "\"_xlqadd\"", ")", ";", "set_optab_libfunc", "(", "sub_optab", ",", "mode", ",", "\"_xlqsub\"", ")", ";", "set_optab_libfunc", "(", "smul_optab", ",", "mode", ",", "\"_xlqmul\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "mode", ",", "\"_xlqdiv\"", ")", ";", "}", "if", "(", "mode", "==", "IFmode", ")", "{", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "SDmode", ",", "\"__dpd_extendsdtf\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "mode", ",", "DDmode", ",", "\"__dpd_extendddtf\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "mode", ",", "TDmode", ",", "\"__dpd_trunctdtf\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SDmode", ",", "mode", ",", "\"__dpd_trunctfsd\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "DDmode", ",", "mode", ",", "\"__dpd_trunctfdd\"", ")", ";", "set_conv_libfunc", "(", "sext_optab", ",", "TDmode", ",", "mode", ",", "\"__dpd_extendtftd\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "DImode", ",", "mode", ",", "\"__fixtfdi\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "DImode", ",", "mode", ",", "\"__fixunstfdi\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "DImode", ",", "\"__floatditf\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "DImode", ",", "\"__floatunditf\"", ")", ";", "if", "(", "TARGET_POWERPC64", ")", "{", "set_conv_libfunc", "(", "sfix_optab", ",", "TImode", ",", "mode", ",", "\"__fixtfti\"", ")", ";", "set_conv_libfunc", "(", "ufix_optab", ",", "TImode", ",", "mode", ",", "\"__fixunstfti\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "mode", ",", "TImode", ",", "\"__floattitf\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "mode", ",", "TImode", ",", "\"__floatuntitf\"", ")", ";", "}", "}", "}", "</s>" ]

[ "Set", "up", "AIX/Darwin/64-bit", "Linux", "quad", "floating", "point", "routines", "." ]

[ "rs6000", "\"__gcc_qadd\"", "\"__gcc_qsub\"", "\"__gcc_qmul\"", "\"__gcc_qdiv\"", "\"__gcc_qneg\"", "\"__gcc_qeq\"", "\"__gcc_qne\"", "\"__gcc_qgt\"", "\"__gcc_qge\"", "\"__gcc_qlt\"", "\"__gcc_qle\"", "\"__gcc_qunord\"", "\"__gcc_stoq\"", "\"__gcc_dtoq\"", "\"__gcc_qtos\"", "\"__gcc_qtod\"", "\"__gcc_qtoi\"", "\"__gcc_qtou\"", "\"__gcc_itoq\"", "\"__gcc_utoq\"", "\"_xlqadd\"", "\"_xlqsub\"", "\"_xlqmul\"", "\"_xlqdiv\"", "\"__dpd_extendsdtf\"", "\"__dpd_extendddtf\"", "\"__dpd_trunctdtf\"", "\"__dpd_trunctfsd\"", "\"__dpd_trunctfdd\"", "\"__dpd_extendtftd\"", "\"__fixtfdi\"", "\"__fixunstfdi\"", "\"__floatditf\"", "\"__floatunditf\"", "\"__fixtfti\"", "\"__fixunstfti\"", "\"__floattitf\"", "\"__floatuntitf\"" ]

[]

[ "<s>", "Value", "*", "PPCTargetLowering", "::", "emitMaskedAtomicRMWIntrinsic", "(", "IRBuilderBase", "&", "Builder", ",", "AtomicRMWInst", "*", "AI", ",", "Value", "*", "AlignedAddr", ",", "Value", "*", "Incr", ",", "Value", "*", "Mask", ",", "Value", "*", "ShiftAmt", ",", "AtomicOrdering", "Ord", ")", "const", "{", "assert", "(", "EnableQuadwordAtomics", "&&", "Subtarget", ".", "hasQuadwordAtomics", "(", ")", "&&", "\"Only support quadword now\"", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Type", "*", "ValTy", "=", "AlignedAddr", "->", "getType", "(", ")", "->", "getPointerElementType", "(", ")", ";", "assert", "(", "ValTy", "->", "getPrimitiveSizeInBits", "(", ")", "==", "128", ")", ";", "Function", "*", "RMW", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "getIntrinsicForAtomicRMWBinOp128", "(", "AI", "->", "getOperation", "(", ")", ")", ")", ";", "Type", "*", "Int64Ty", "=", "Type", "::", "getInt64Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "IncrLo", "=", "Builder", ".", "CreateTrunc", "(", "Incr", ",", "Int64Ty", ",", "\"incr_lo\"", ")", ";", "Value", "*", "IncrHi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Incr", ",", "64", ")", ",", "Int64Ty", ",", "\"incr_hi\"", ")", ";", "Value", "*", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "AlignedAddr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "Value", "*", "LoHi", "=", "Builder", ".", "CreateCall", "(", "RMW", ",", "{", "Addr", ",", "IncrLo", ",", "IncrHi", "}", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "0", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateExtractValue", "(", "LoHi", ",", "1", ",", "\"hi\"", ")", ";", "Lo", "=", "Builder", ".", "CreateZExt", "(", "Lo", ",", "ValTy", ",", "\"lo64\"", ")", ";", "Hi", "=", "Builder", ".", "CreateZExt", "(", "Hi", ",", "ValTy", ",", "\"hi64\"", ")", ";", "return", "Builder", ".", "CreateOr", "(", "Lo", ",", "Builder", ".", "CreateShl", "(", "Hi", ",", "ConstantInt", "::", "get", "(", "ValTy", ",", "64", ")", ")", ",", "\"val64\"", ")", ";", "}", "</s>" ]

[ "Perform", "a", "masked", "atomicrmw", "using", "a", "target-specific", "intrinsic", "." ]

[ "PowerPC", "PPC", "\"Only support quadword now\"", "128", "Intrinsic::getDeclaration", "\"incr_lo\"", "64", "\"incr_hi\"", "0", "\"lo\"", "1", "\"hi\"", "\"lo64\"", "\"hi64\"", "64", "\"val64\"" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitMachineConstantPoolValue", "(", "MachineConstantPoolValue", "*", "MCPV", ")", "{", "const", "DataLayout", "&", "DL", "=", "getDataLayout", "(", ")", ";", "int", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "MCPV", "->", "getType", "(", ")", ")", ";", "ARMConstantPoolValue", "*", "ACPV", "=", "static_cast", "<", "ARMConstantPoolValue", "*", ">", "(", "MCPV", ")", ";", "if", "(", "ACPV", "->", "isPromotedGlobal", "(", ")", ")", "{", "auto", "*", "ACPC", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", ";", "for", "(", "const", "auto", "*", "GV", ":", "ACPC", "->", "promotedGlobals", "(", ")", ")", "{", "if", "(", "!", "EmittedPromotedGlobalLabels", ".", "count", "(", "GV", ")", ")", "{", "MCSymbol", "*", "GVSym", "=", "getSymbol", "(", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "GVSym", ")", ";", "EmittedPromotedGlobalLabels", ".", "insert", "(", "GV", ")", ";", "}", "}", "return", "emitGlobalConstant", "(", "DL", ",", "ACPC", "->", "getPromotedGlobalInit", "(", ")", ")", ";", "}", "MCSymbol", "*", "MCSym", ";", "if", "(", "ACPV", "->", "isLSDA", "(", ")", ")", "{", "MCSym", "=", "getMBBExceptionSym", "(", "MF", "->", "front", "(", ")", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isBlockAddress", "(", ")", ")", "{", "const", "BlockAddress", "*", "BA", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getBlockAddress", "(", ")", ";", "MCSym", "=", "GetBlockAddressSymbol", "(", "BA", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isGlobalValue", "(", ")", ")", "{", "const", "GlobalValue", "*", "GV", "=", "cast", "<", "ARMConstantPoolConstant", ">", "(", "ACPV", ")", "->", "getGV", "(", ")", ";", "unsigned", "char", "TF", "=", "Subtarget", "->", "isTargetMachO", "(", ")", "?", "ARMII", "::", "MO_NONLAZY", ":", "0", ";", "MCSym", "=", "GetARMGVSymbol", "(", "GV", ",", "TF", ")", ";", "}", "else", "if", "(", "ACPV", "->", "isMachineBasicBlock", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "cast", "<", "ARMConstantPoolMBB", ">", "(", "ACPV", ")", "->", "getMBB", "(", ")", ";", "MCSym", "=", "MBB", "->", "getSymbol", "(", ")", ";", "}", "else", "{", "assert", "(", "ACPV", "->", "isExtSymbol", "(", ")", "&&", "\"unrecognized constant pool value\"", ")", ";", "auto", "Sym", "=", "cast", "<", "ARMConstantPoolSymbol", ">", "(", "ACPV", ")", "->", "getSymbol", "(", ")", ";", "MCSym", "=", "GetExternalSymbolSymbol", "(", "Sym", ")", ";", "}", "const", "MCExpr", "*", "Expr", "=", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ",", "getModifierVariantKind", "(", "ACPV", "->", "getModifier", "(", ")", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ")", "{", "MCSymbol", "*", "PCLabel", "=", "getPICLabel", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ",", "getFunctionNumber", "(", ")", ",", "ACPV", "->", "getLabelId", "(", ")", ",", "OutContext", ")", ";", "const", "MCExpr", "*", "PCRelExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "PCLabel", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createAdd", "(", "PCRelExpr", ",", "MCConstantExpr", "::", "create", "(", "ACPV", "->", "getPCAdjustment", "(", ")", ",", "OutContext", ")", ",", "OutContext", ")", ";", "if", "(", "ACPV", "->", "mustAddCurrentAddress", "(", ")", ")", "{", "MCSymbol", "*", "DotSym", "=", "OutContext", ".", "createTempSymbol", "(", ")", ";", "OutStreamer", "->", "emitLabel", "(", "DotSym", ")", ";", "const", "MCExpr", "*", "DotExpr", "=", "MCSymbolRefExpr", "::", "create", "(", "DotSym", ",", "OutContext", ")", ";", "PCRelExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "PCRelExpr", ",", "DotExpr", ",", "OutContext", ")", ";", "}", "Expr", "=", "MCBinaryExpr", "::", "createSub", "(", "Expr", ",", "PCRelExpr", ",", "OutContext", ")", ";", "}", "OutStreamer", "->", "emitValue", "(", "Expr", ",", "Size", ")", ";", "}", "</s>" ]

[ "EmitMachineConstantPoolValue", "-", "Print", "a", "machine", "constantpool", "value", "to", "the", ".s", "file", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARMII::MO_NONLAZY", "0", "ARM", "ARM", "\"unrecognized constant pool value\"", "ARM" ]

[]

[ "<s>", "void", "pru_register_abicheck_pass", "(", "void", ")", "{", "opt_pass", "*", "tiabi_check", "=", "make_pass_tiabi_check", "(", "g", ")", ";", "struct", "register_pass_info", "tiabi_check_info", "=", "{", "tiabi_check", ",", "\"*warn_unused_result\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "tiabi_check_info", ")", ";", "}", "</s>" ]

[ "Register", "as", "early", "as", "possible", "." ]

[ "pru", "\"*warn_unused_result\"", "1" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "X86SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "X86SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "X86SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "X86SelectCmp", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "return", "X86SelectZExt", "(", "I", ")", ";", "case", "Instruction", "::", "SExt", ":", "return", "X86SelectSExt", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "X86SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "case", "Instruction", "::", "Shl", ":", "return", "X86SelectShift", "(", "I", ")", ";", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "URem", ":", "return", "X86SelectDivRem", "(", "I", ")", ";", "case", "Instruction", "::", "Select", ":", "return", "X86SelectSelect", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "X86SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "X86SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "X86SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "X86SelectSIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "X86SelectUIToFP", "(", "I", ")", ";", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "{", "EVT", "SrcVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "EVT", "DstVT", "=", "TLI", ".", "getValueType", "(", "DL", ",", "I", "->", "getType", "(", ")", ")", ";", "if", "(", "DstVT", ".", "bitsGT", "(", "SrcVT", ")", ")", "return", "X86SelectZExt", "(", "I", ")", ";", "if", "(", "DstVT", ".", "bitsLT", "(", "SrcVT", ")", ")", "return", "X86SelectTrunc", "(", "I", ")", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "Reg", "==", "0", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "case", "Instruction", "::", "BitCast", ":", "{", "if", "(", "!", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "false", ";", "MVT", "SrcVT", ",", "DstVT", ";", "if", "(", "!", "isTypeLegal", "(", "I", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ",", "SrcVT", ")", "||", "!", "isTypeLegal", "(", "I", "->", "getType", "(", ")", ",", "DstVT", ")", ")", "return", "false", ";", "if", "(", "!", "SrcVT", ".", "isVector", "(", ")", "||", "!", "DstVT", ".", "isVector", "(", ")", "||", "SrcVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "||", "DstVT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "false", ";", "unsigned", "Reg", "=", "getRegForValue", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "Reg", "==", "0", ")", "return", "false", ";", "updateValueMap", "(", "I", ",", "Reg", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "X86", "0", "X86", "X86", "0", "0", "0", "MVT::i1", "MVT::i1", "0", "0" ]

[]

[ "<s>", "bool", "AArch64LoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "Subtarget", "=", "&", "static_cast", "<", "const", "AArch64Subtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "ModifiedRegUnits", ".", "init", "(", "*", "TRI", ")", ";", "UsedRegUnits", ".", "init", "(", "*", "TRI", ")", ";", "DefinedInBB", ".", "init", "(", "*", "TRI", ")", ";", "bool", "Modified", "=", "false", ";", "bool", "enableNarrowZeroStOpt", "=", "!", "Subtarget", "->", "requiresStrictAlign", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "{", "auto", "M", "=", "optimizeBlock", "(", "MBB", ",", "enableNarrowZeroStOpt", ")", ";", "Modified", "|=", "M", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "DLXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "void", "Nios2DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2", "\"== \"", "\"\\n\"", "1" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "MBB", "->", "pred_begin", "(", ")", ";", "if", "(", "const", "BasicBlock", "*", "bb", "=", "Pred", "->", "getBasicBlock", "(", ")", ")", "if", "(", "isa", "<", "SwitchInst", ">", "(", "bb", "->", "getTerminator", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MBB", "->", "isEHPad", "(", ")", "||", "MBB", "->", "pred_empty", "(", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "!", "I", "->", "isBarrier", "(", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "aarch64_register_pragmas", "(", "void", ")", "{", "targetm", ".", "target_option", ".", "pragma_parse", "=", "aarch64_pragma_target_parse", ";", "}", "</s>" ]

[ "Implement", "REGISTER_TARGET_PRAGMAS", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "bool", "use_toc_relative_ref", "(", "rtx", "sym", ")", "{", "return", "(", "(", "constant_pool_expr_p", "(", "sym", ")", "&&", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "get_pool_constant", "(", "sym", ")", ",", "get_pool_mode", "(", "sym", ")", ")", ")", "||", "(", "TARGET_CMODEL", "==", "CMODEL_MEDIUM", "&&", "SYMBOL_REF_LOCAL_P", "(", "sym", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "the", "given", "SYMBOL_REF", "refers", "to", "a", "constant", "pool", "entry", "that", "we", "have", "put", "in", "the", "TOC", ",", "or", "for", "cmodel=medium", ",", "if", "the", "SYMBOL_REF", "can", "be", "addressed", "relative", "to", "the", "toc", "pointer", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "msp430_special_register_convention_p", "(", "const", "char", "*", "name", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "special_convention_function_names", "[", "i", "]", ";", "i", "++", ")", "if", "(", "!", "strcmp", "(", "name", ",", "special_convention_function_names", "[", "i", "]", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "TRUE", "if", "the", "function", "passed", "is", "a", "``", "speical", "''", "function", ".", "Special", "functions", "pass", "two", "DImode", "parameters", "in", "registers", "." ]

[ "msp430", "0" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isPredicable", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "getDesc", "(", ")", ".", "isPredicable", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isCall", "(", ")", "||", "isTailCall", "(", "MI", ")", ")", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "usePredicatedCalls", "(", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

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

[]

[ "<s>", "bool", "X86LoadValueInjectionLoadHardeningUnoptimizedPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" *****\\n\"", ")", ";", "const", "X86Subtarget", "*", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", "->", "useLVILoadHardening", "(", ")", ")", "return", "false", ";", "if", "(", "!", "STI", "->", "is64Bit", "(", ")", ")", "report_fatal_error", "(", "\"LVI load hardening is only supported on 64-bit\"", ",", "false", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "F", ".", "hasOptNone", "(", ")", "&&", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "bool", "Modified", "=", "false", ";", "++", "NumFunctionsConsidered", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "MI", ".", "mayLoad", "(", ")", "||", "MI", ".", "getOpcode", "(", ")", "==", "X86", "::", "LFENCE", "||", "MI", ".", "getOpcode", "(", ")", "==", "X86", "::", "MFENCE", ")", "continue", ";", "MachineBasicBlock", "::", "iterator", "InsertionPt", "=", "MI", ".", "getNextNode", "(", ")", "?", "MI", ".", "getNextNode", "(", ")", ":", "MBB", ".", "end", "(", ")", ";", "BuildMI", "(", "MBB", ",", "InsertionPt", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "X86", "::", "LFENCE", ")", ")", ";", "++", "NumFences", ";", "Modified", "=", "true", ";", "}", "}", "if", "(", "Modified", ")", "++", "NumFunctionsMitigated", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"***** \"", "\" : \"", "\" *****\\n\"", "X86", "X86", "\"LVI load hardening is only supported on 64-bit\"", "X86::LFENCE", "X86::MFENCE", "X86::LFENCE" ]

[]

[ "<s>", "static", "unsigned", "int", "nvptx_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "boundary", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "if", "(", "boundary", ">", "BITS_PER_WORD", ")", "return", "2", "*", "BITS_PER_WORD", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", ">", "4", ")", "return", "2", "*", "BITS_PER_WORD", ";", "if", "(", "boundary", "<", "BITS_PER_WORD", ")", "{", "if", "(", "size", ">=", "3", ")", "return", "BITS_PER_WORD", ";", "if", "(", "size", ">=", "2", ")", "return", "2", "*", "BITS_PER_UNIT", ";", "}", "}", "return", "boundary", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_BOUNDARY", "." ]

[ "nvptx", "2", "4", "2", "3", "2", "2" ]

[]

[ "<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", ".", "isABI_O32", "(", ")", ",", "Subtarget", ".", "isFP64bit", "(", ")", ",", "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>", "MVT", "X86TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v32i8", ";", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "16", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "64", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "return", "MVT", "::", "i8", ";", "if", "(", "(", "VT", "==", "MVT", "::", "v32i16", "||", "VT", "==", "MVT", "::", "v64i8", ")", "&&", "!", "EnableOldKNLABI", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "MVT", "::", "v16i32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "X86", "X86", "MVT::v32i1", "MVT::v32i8", "MVT::i1", "16", "64", "MVT::i8", "MVT::v32i16", "MVT::v64i8", "MVT::v16i32" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "bool", "UsePrefetching", "=", "TM", "->", "getTargetTriple", "(", ")", ".", "getVendor", "(", ")", "==", "Triple", "::", "BGQ", "&&", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ";", "if", "(", "EnablePrefetch", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "UsePrefetching", "=", "EnablePrefetch", ";", "if", "(", "UsePrefetching", ")", "addPass", "(", "createLoopDataPrefetchPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", ">=", "CodeGenOpt", "::", "Default", "&&", "EnableGEPOpt", ")", "{", "addPass", "(", "createSeparateConstOffsetFromGEPPass", "(", "true", ")", ")", ";", "addPass", "(", "createEarlyCSEPass", "(", ")", ")", ";", "addPass", "(", "createLICMPass", "(", ")", ")", ";", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "uint16_t", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "WebKit_JS", ":", "return", "CSR_64_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "return", "CSR_MostRegs_64_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX512", "(", ")", ";", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_MostRegs_64_SaveList", ";", "break", ";", "default", ":", "break", ";", "}", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "bool", "IsNaCl", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "isTargetNaCl", "(", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "IsNaCl", ")", "{", "if", "(", "CallsEHReturn", ")", "return", "CSR_NaCl64EHRet_SaveList", ";", "return", "CSR_NaCl64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "useSmallSection", "(", ")", ")", "return", "false", ";", "const", "GlobalVariable", "*", "GVA", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GV", ")", ";", "if", "(", "!", "GVA", ")", "return", "false", ";", "if", "(", "!", "Kind", ".", "isBSS", "(", ")", "&&", "!", "Kind", ".", "isDataRel", "(", ")", ")", "return", "false", ";", "if", "(", "Kind", ".", "isMergeable1ByteCString", "(", ")", ")", "return", "false", ";", "Type", "*", "Ty", "=", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ";", "return", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "Ty", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "is", "(", "KindTy", "K", ")", "const", "{", "return", "(", "Kind", "==", "K", ")", ";", "}", "</s>" ]

[ "Check", "if", "the", "current", "token", "has", "kind", "K", "." ]

[ "MOS" ]

[]

[ "<s>", "bool", "MipsCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "Mips", "::", "RetRA", ")", ";", "if", "(", "Val", "!=", "nullptr", "&&", "!", "isSupportedType", "(", "Val", "->", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "VRegs", ".", "empty", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "MipsTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "MipsTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "Val", "->", "getType", "(", ")", "->", "getContext", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitEVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "Val", "->", "getType", "(", ")", ",", "SplitEVTs", ")", ";", "assert", "(", "VRegs", ".", "size", "(", ")", "==", "SplitEVTs", ".", "size", "(", ")", "&&", "\"For each split Type there should be exactly one VReg.\"", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "RetInfos", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "OrigArgIndices", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SplitEVTs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "ArgInfo", "CurArgInfo", "=", "ArgInfo", "{", "VRegs", "[", "i", "]", ",", "SplitEVTs", "[", "i", "]", ".", "getTypeForEVT", "(", "Ctx", ")", "}", ";", "setArgFlags", "(", "CurArgInfo", ",", "AttributeList", "::", "ReturnIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "CurArgInfo", ",", "0", ",", "RetInfos", ",", "OrigArgIndices", ")", ";", "}", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "8", ">", "Outs", ";", "subTargetRegTypeForCallingConv", "(", "F", ",", "RetInfos", ",", "OrigArgIndices", ",", "Outs", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "MipsCCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "TLI", ".", "CCAssignFnForReturn", "(", ")", ")", ";", "setLocInfo", "(", "ArgLocs", ",", "Outs", ")", ";", "OutgoingValueHandler", "RetHandler", "(", "MIRBuilder", ",", "MF", ".", "getRegInfo", "(", ")", ",", "Ret", ")", ";", "if", "(", "!", "RetHandler", ".", "handle", "(", "ArgLocs", ",", "RetInfos", ")", ")", "{", "return", "false", ";", "}", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::RetRA", "Mips", "Mips", "4", "\"For each split Type there should be exactly one VReg.\"", "8", "8", "0", "0", "ISD::OutputArg", "8", "16", "Mips" ]

[]

[ "<s>", "static", "void", "arm_pragma_arm", "(", "cpp_reader", "*", ")", "{", "tree", "x", ";", "if", "(", "pragma_lex", "(", "&", "x", ")", "!=", "CPP_STRING", ")", "{", "error", "(", "\"%<#pragma GCC arm%> requires a string parameter\"", ")", ";", "return", ";", "}", "const", "char", "*", "name", "=", "TREE_STRING_POINTER", "(", "x", ")", ";", "if", "(", "strcmp", "(", "name", ",", "\"arm_mve_types.h\"", ")", "==", "0", ")", "arm_mve", "::", "handle_arm_mve_types_h", "(", ")", ";", "else", "error", "(", "\"unknown %<#pragma GCC arm%> option %qs\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Implement", "``", "#", "pragma", "GCC", "arm", "''", "." ]

[ "arm", "\"%<#pragma GCC arm%> requires a string parameter\"", "\"arm_mve_types.h\"", "0", "arm_mve::handle_arm_mve_types_h", "\"unknown %<#pragma GCC arm%> option %qs\"" ]

[]

[ "<s>", "bool", "AArch64RegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "&", "TFI", "=", "*", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", ".", "hasFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

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

[]

[ "<s>", "void", "GeneralShuffle", "::", "add", "(", "SDValue", "Op", ",", "unsigned", "Elem", ")", "{", "unsigned", "BytesPerElement", "=", "VT", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", ")", ";", "EVT", "FromVT", "=", "Op", ".", "getNode", "(", ")", "?", "Op", ".", "getValueType", "(", ")", ":", "VT", ";", "unsigned", "FromBytesPerElement", "=", "FromVT", ".", "getVectorElementType", "(", ")", ".", "getStoreSize", "(", ")", ";", "assert", "(", "FromBytesPerElement", ">=", "BytesPerElement", "&&", "\"Invalid EXTRACT_VECTOR_ELT\"", ")", ";", "unsigned", "Byte", "=", "(", "(", "Elem", "*", "FromBytesPerElement", ")", "%", "SystemZ", "::", "VectorBytes", "+", "(", "FromBytesPerElement", "-", "BytesPerElement", ")", ")", ";", "while", "(", "Op", ".", "getNode", "(", ")", ")", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "BITCAST", ")", "Op", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "else", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "VECTOR_SHUFFLE", "&&", "Op", ".", "hasOneUse", "(", ")", ")", "{", "SmallVector", "<", "int", ",", "SystemZ", "::", "VectorBytes", ">", "OpBytes", ";", "getVPermMask", "(", "cast", "<", "ShuffleVectorSDNode", ">", "(", "Op", ")", ",", "OpBytes", ")", ";", "int", "NewByte", ";", "if", "(", "!", "getShuffleInput", "(", "OpBytes", ",", "Byte", ",", "BytesPerElement", ",", "NewByte", ")", ")", "break", ";", "if", "(", "NewByte", "<", "0", ")", "{", "addUndef", "(", ")", ";", "return", ";", "}", "Op", "=", "Op", ".", "getOperand", "(", "unsigned", "(", "NewByte", ")", "/", "SystemZ", "::", "VectorBytes", ")", ";", "Byte", "=", "unsigned", "(", "NewByte", ")", "%", "SystemZ", "::", "VectorBytes", ";", "}", "else", "if", "(", "Op", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "{", "addUndef", "(", ")", ";", "return", ";", "}", "else", "break", ";", "}", "unsigned", "OpNo", "=", "0", ";", "for", "(", ";", "OpNo", "<", "Ops", ".", "size", "(", ")", ";", "++", "OpNo", ")", "if", "(", "Ops", "[", "OpNo", "]", "==", "Op", ")", "break", ";", "if", "(", "OpNo", "==", "Ops", ".", "size", "(", ")", ")", "Ops", ".", "push_back", "(", "Op", ")", ";", "unsigned", "Base", "=", "OpNo", "*", "SystemZ", "::", "VectorBytes", "+", "Byte", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "BytesPerElement", ";", "++", "I", ")", "Bytes", ".", "push_back", "(", "Base", "+", "I", ")", ";", "}", "</s>" ]

[ "Add", "a", "string", "to", "the", "builder", "." ]

[ "SystemZ", "\"Invalid EXTRACT_VECTOR_ELT\"", "SystemZ::VectorBytes", "ISD::BITCAST", "0", "ISD::VECTOR_SHUFFLE", "SystemZ::VectorBytes", "0", "SystemZ::VectorBytes", "SystemZ::VectorBytes", "ISD::UNDEF", "0", "SystemZ::VectorBytes", "0" ]

[]

[ "<s>", "void", "Nios2InstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "static", "void", "ix86_expand_divmod_libfunc", "(", "rtx", "libfunc", ",", "machine_mode", "mode", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "*", "quot_p", ",", "rtx", "*", "rem_p", ")", "{", "rtx", "rem", "=", "assign_386_stack_local", "(", "mode", ",", "SLOT_TEMP", ")", ";", "rtx", "quot", "=", "emit_library_call_value", "(", "libfunc", ",", "NULL_RTX", ",", "LCT_NORMAL", ",", "mode", ",", "3", ",", "op0", ",", "GET_MODE", "(", "op0", ")", ",", "op1", ",", "GET_MODE", "(", "op1", ")", ",", "XEXP", "(", "rem", ",", "0", ")", ",", "Pmode", ")", ";", "*", "quot_p", "=", "quot", ";", "*", "rem_p", "=", "rem", ";", "}", "</s>" ]

[ "Generate", "call", "to", "__divmoddi4", "." ]

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

[]

[ "<s>", "llvm", "::", "FastISel", "*", "X86", "::", "createFastISel", "(", "MachineFunction", "&", "mf", ",", "DenseMap", "<", "const", "Value", "*", ",", "unsigned", ">", "&", "vm", ",", "DenseMap", "<", "const", "BasicBlock", "*", ",", "MachineBasicBlock", "*", ">", "&", "bm", ",", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "&", "am", ",", "SmallSet", "<", "const", "Instruction", "*", ",", "8", ">", "&", "cil", ")", "{", "return", "new", "X86FastISel", "(", "mf", ",", "vm", ",", "bm", ",", "am", ",", "cil", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "X86", "X86::createFastISel", "8", "X86" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "unsigned", "oper", "=", "0", ";", "oper", "<", "MI", ".", "getNumOperands", "(", ")", ";", "++", "oper", ")", "{", "MachineOperand", "MO", "=", "MI", ".", "getOperand", "(", "oper", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "HRI", ".", "getMinimalPhysRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "RC", "==", "&", "Hexagon", "::", "PredRegsRegClass", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "return", "true", ";", "}", "continue", ";", "}", "else", "if", "(", "MO", ".", "isRegMask", "(", ")", ")", "{", "for", "(", "unsigned", "PR", ":", "Hexagon", "::", "PredRegsRegClass", ")", "{", "if", "(", "!", "MI", ".", "modifiesRegister", "(", "PR", ",", "&", "HRI", ")", ")", "continue", ";", "Pred", ".", "push_back", "(", "MO", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "0", "Hexagon::PredRegsRegClass", "Hexagon::PredRegsRegClass" ]

[]

[ "<s>", "void", "BPFFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "SDNode", "*", "TOYDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_4", ")", ";", "else", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_16", ")", ";", "std", "::", "string", "Arch", "=", "\"rv32\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "Feature64Bit", ")", ")", "Arch", "=", "\"rv64\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "Arch", "+=", "\"e1p9\"", ";", "else", "Arch", "+=", "\"i2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtM", ")", ")", "Arch", "+=", "\"_m2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtA", ")", ")", "Arch", "+=", "\"_a2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtF", ")", ")", "Arch", "+=", "\"_f2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtD", ")", ")", "Arch", "+=", "\"_d2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtC", ")", ")", "Arch", "+=", "\"_c2p0\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtB", ")", ")", "Arch", "+=", "\"_b0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtV", ")", ")", "Arch", "+=", "\"_v0p10\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZfh", ")", ")", "Arch", "+=", "\"_zfh0p1\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZba", ")", ")", "Arch", "+=", "\"_zba0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbb", ")", ")", "Arch", "+=", "\"_zbb0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbc", ")", ")", "Arch", "+=", "\"_zbc0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbe", ")", ")", "Arch", "+=", "\"_zbe0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbf", ")", ")", "Arch", "+=", "\"_zbf0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbm", ")", ")", "Arch", "+=", "\"_zbm0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbp", ")", ")", "Arch", "+=", "\"_zbp0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbproposedc", ")", ")", "Arch", "+=", "\"_zbproposedc0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbr", ")", ")", "Arch", "+=", "\"_zbr0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbs", ")", ")", "Arch", "+=", "\"_zbs0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZbt", ")", ")", "Arch", "+=", "\"_zbt0p93\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureExtZvamo", ")", ")", "Arch", "+=", "\"_zvamo0p10\"", ";", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureStdExtZvlsseg", ")", ")", "Arch", "+=", "\"_zvlsseg0p10\"", ";", "emitTextAttribute", "(", "RISCVAttrs", "::", "ARCH", ",", "Arch", ")", ";", "}", "</s>" ]

[ "Emit", "the", "build", "attributes", "that", "only", "depend", "on", "the", "hardware", "that", "we", "expect", "." ]

[ "RI5CY", "RISCV", "RISCV::FeatureRV32E", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_4", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_16", "\"rv32\"", "RISCV::Feature64Bit", "\"rv64\"", "RISCV::FeatureRV32E", "\"e1p9\"", "\"i2p0\"", "RISCV::FeatureStdExtM", "\"_m2p0\"", "RISCV::FeatureStdExtA", "\"_a2p0\"", "RISCV::FeatureStdExtF", "\"_f2p0\"", "RISCV::FeatureStdExtD", "\"_d2p0\"", "RISCV::FeatureStdExtC", "\"_c2p0\"", "RISCV::FeatureStdExtB", "\"_b0p93\"", "RISCV::FeatureStdExtV", "\"_v0p10\"", "RISCV::FeatureExtZfh", "\"_zfh0p1\"", "RISCV::FeatureExtZba", "\"_zba0p93\"", "RISCV::FeatureExtZbb", "\"_zbb0p93\"", "RISCV::FeatureExtZbc", "\"_zbc0p93\"", "RISCV::FeatureExtZbe", "\"_zbe0p93\"", "RISCV::FeatureExtZbf", "\"_zbf0p93\"", "RISCV::FeatureExtZbm", "\"_zbm0p93\"", "RISCV::FeatureExtZbp", "\"_zbp0p93\"", "RISCV::FeatureExtZbproposedc", "\"_zbproposedc0p93\"", "RISCV::FeatureExtZbr", "\"_zbr0p93\"", "RISCV::FeatureExtZbs", "\"_zbs0p93\"", "RISCV::FeatureExtZbt", "\"_zbt0p93\"", "RISCV::FeatureExtZvamo", "\"_zvamo0p10\"", "RISCV::FeatureStdExtZvlsseg", "\"_zvlsseg0p10\"", "RISCVAttrs::ARCH" ]

[]

[ "<s>", "static", "void", "cr16_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "int", "ptr_dereference", "=", "0", ";", "switch", "(", "code", ")", "{", "case", "'d'", ":", "{", "const", "char", "*", "cr16_cmp_str", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "EQ", ":", "cr16_cmp_str", "=", "\"eq\"", ";", "break", ";", "case", "NE", ":", "cr16_cmp_str", "=", "\"ne\"", ";", "break", ";", "case", "GT", ":", "cr16_cmp_str", "=", "\"lt\"", ";", "break", ";", "case", "GTU", ":", "cr16_cmp_str", "=", "\"lo\"", ";", "break", ";", "case", "LT", ":", "cr16_cmp_str", "=", "\"gt\"", ";", "break", ";", "case", "LTU", ":", "cr16_cmp_str", "=", "\"hi\"", ";", "break", ";", "case", "GE", ":", "cr16_cmp_str", "=", "\"le\"", ";", "break", ";", "case", "GEU", ":", "cr16_cmp_str", "=", "\"ls\"", ";", "break", ";", "case", "LE", ":", "cr16_cmp_str", "=", "\"ge\"", ";", "break", ";", "case", "LEU", ":", "cr16_cmp_str", "=", "\"hs\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"%s\"", ",", "cr16_cmp_str", ")", ";", "return", ";", "}", "case", "'$'", ":", "putc", "(", "'$'", ",", "file", ")", ";", "return", ";", "case", "'p'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "return", ";", "}", "break", ";", "case", "'b'", ":", "fprintf", "(", "file", ",", "\"0x%lx\"", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "'r'", ":", "fprintf", "(", "file", ",", "\"%d\"", ",", "cr16_operand_bit_pos", "(", "INTVAL", "(", "x", ")", ",", "0", ")", ")", ";", "return", ";", "case", "'s'", ":", "fprintf", "(", "file", ",", "\"%d\"", ",", "cr16_operand_bit_pos", "(", "INTVAL", "(", "x", ")", ",", "1", ")", ")", ";", "return", ";", "case", "'g'", ":", "ptr_dereference", "=", "1", ";", "case", "'f'", ":", "case", "0", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "if", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "BITS_PER_WORD", ")", "{", "if", "(", "LONG_REG_P", "(", "REGNO", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"(%s,%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "1", "]", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "{", "long", "l", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "l", ")", ";", "fprintf", "(", "file", ",", "\"$0x%lx\"", ",", "l", ")", ";", "return", ";", "}", "case", "CONST_INT", ":", "{", "fprintf", "(", "file", ",", "\"$%ld\"", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "}", "case", "UNSPEC", ":", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "if", "(", "!", "ptr_dereference", ")", "{", "putc", "(", "'$'", ",", "file", ")", ";", "}", "cr16_print_operand_address", "(", "file", ",", "VOIDmode", ",", "x", ")", ";", "return", ";", "}", "gcc_unreachable", "(", ")", ";", "default", ":", "output_operand_lossage", "(", "\"invalid %%xn code\"", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "PRINT_OPERAND", "defined", "in", "cr16.h", "." ]

[ "cr16", "0", "\"eq\"", "\"ne\"", "\"lt\"", "\"lo\"", "\"gt\"", "\"hi\"", "\"le\"", "\"ls\"", "\"ge\"", "\"hs\"", "\"%s\"", "\"%s\"", "\"0x%lx\"", "\"%d\"", "0", "\"%d\"", "1", "1", "0", "\"(%s)\"", "\"(%s,%s)\"", "1", "\"%s\"", "0", "\"$0x%lx\"", "\"$%ld\"", "1", "\"invalid %%xn code\"" ]

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "Options", ".", "MCOptions", ",", "LittleEndian", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "getEffectiveCodeModel", "(", "TT", ",", "CM", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "isLittle", "(", "LittleEndian", ")", "{", "initAsmInfo", "(", ")", ";", "if", "(", "TT", ".", "isOSBinFormatMachO", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "if", "(", "getOptLevel", "(", ")", "<=", "EnableGlobalISelAtO", ")", "setGlobalISel", "(", "true", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "rtx_insn", "*", "calculate_pic_address_constant", "(", "rtx", "reg", ",", "rtx", "pic_reg", ",", "rtx", "orig", ")", "{", "rtx", "pat", ";", "rtx", "mem", ";", "pat", "=", "gen_calculate_pic_address", "(", "reg", ",", "pic_reg", ",", "orig", ")", ";", "mem", "=", "SET_SRC", "(", "pat", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", "&&", "!", "MEM_VOLATILE_P", "(", "mem", ")", ")", ";", "MEM_READONLY_P", "(", "mem", ")", "=", "1", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "return", "emit_insn", "(", "pat", ")", ";", "}", "</s>" ]

[ "Generate", "insns", "to", "calculate", "the", "address", "of", "ORIG", "in", "pic", "mode", "." ]

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

[]

[ "<s>", "static", "bool", "nvptx_strict_argument_naming", "(", "cumulative_args_t", "cum_v", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "return", "cum", "->", "fntype", "==", "NULL_TREE", "||", "stdarg_p", "(", "cum", "->", "fntype", ")", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_STRICT_ARGUMENT_NAMING", "target", "hook", ".", "For", "nvptx", ",", "we", "know", "how", "to", "handle", "functions", "declared", "as", "stdarg", ":", "by", "passing", "an", "extra", "pointer", "to", "the", "unnamed", "arguments", ".", "However", ",", "the", "Fortran", "frontend", "can", "produce", "a", "different", "situation", ",", "where", "a", "function", "pointer", "is", "declared", "with", "no", "arguments", ",", "but", "the", "actual", "function", "and", "calls", "to", "it", "take", "more", "arguments", ".", "In", "that", "case", ",", "we", "want", "to", "ensure", "the", "call", "matches", "the", "definition", "of", "the", "function", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "NyuziInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "getMemOperand", "(", "MBB", ",", "FrameIndex", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "unsigned", "Opc", "=", "0", ";", "if", "(", "Nyuzi", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Nyuzi", "::", "LW", ";", "else", "if", "(", "Nyuzi", "::", "VR512RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "Nyuzi", "::", "BLOCK_LOADI", ";", "else", "llvm_unreachable", "(", "\"unknown register class in storeRegToStack\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "0", "Nyuzi::GPR32RegClass", "Nyuzi::LW", "Nyuzi::VR512RegClass", "Nyuzi::BLOCK_LOADI", "\"unknown register class in storeRegToStack\"", "0" ]

[]

[ "<s>", "static", "void", "spu_emit_branch_hint", "(", "rtx_insn", "*", "before", ",", "rtx_insn", "*", "branch", ",", "rtx", "target", ",", "int", "distance", ",", "sbitmap", "blocks", ")", "{", "rtx", "branch_label", "=", "0", ";", "rtx_insn", "*", "hint", ";", "rtx_insn", "*", "insn", ";", "rtx_jump_table_data", "*", "table", ";", "if", "(", "before", "==", "0", "||", "branch", "==", "0", "||", "target", "==", "0", ")", "return", ";", "if", "(", "distance", ">", "600", ")", "return", ";", "if", "(", "NOTE_INSN_BASIC_BLOCK_P", "(", "before", ")", ")", "before", "=", "NEXT_INSN", "(", "before", ")", ";", "branch_label", "=", "gen_label_rtx", "(", ")", ";", "LABEL_NUSES", "(", "branch_label", ")", "++", ";", "LABEL_PRESERVE_P", "(", "branch_label", ")", "=", "1", ";", "insn", "=", "emit_label_before", "(", "branch_label", ",", "branch", ")", ";", "branch_label", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "branch_label", ")", ";", "bitmap_set_bit", "(", "blocks", ",", "BLOCK_FOR_INSN", "(", "branch", ")", "->", "index", ")", ";", "hint", "=", "emit_insn_before", "(", "gen_hbr", "(", "branch_label", ",", "target", ")", ",", "before", ")", ";", "recog_memoized", "(", "hint", ")", ";", "INSN_LOCATION", "(", "hint", ")", "=", "INSN_LOCATION", "(", "branch", ")", ";", "HINTED_P", "(", "branch", ")", "=", "1", ";", "if", "(", "GET_CODE", "(", "target", ")", "==", "LABEL_REF", ")", "HINTED_P", "(", "XEXP", "(", "target", ",", "0", ")", ")", "=", "1", ";", "else", "if", "(", "tablejump_p", "(", "branch", ",", "0", ",", "&", "table", ")", ")", "{", "rtvec", "vec", ";", "int", "j", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "table", ")", ")", "==", "ADDR_VEC", ")", "vec", "=", "XVEC", "(", "PATTERN", "(", "table", ")", ",", "0", ")", ";", "else", "vec", "=", "XVEC", "(", "PATTERN", "(", "table", ")", ",", "1", ")", ";", "for", "(", "j", "=", "GET_NUM_ELEM", "(", "vec", ")", "-", "1", ";", "j", ">=", "0", ";", "--", "j", ")", "HINTED_P", "(", "XEXP", "(", "RTVEC_ELT", "(", "vec", ",", "j", ")", ",", "0", ")", ")", "=", "1", ";", "}", "if", "(", "distance", ">=", "588", ")", "{", "insn", "=", "emit_insn_before", "(", "gen_blockage", "(", ")", ",", "hint", ")", ";", "recog_memoized", "(", "insn", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "hint", ")", ";", "}", "else", "if", "(", "distance", "<=", "8", "*", "4", ")", "{", "int", "d", ";", "for", "(", "d", "=", "distance", ";", "d", "<", "8", "*", "4", ";", "d", "+=", "4", ")", "{", "insn", "=", "emit_insn_after", "(", "gen_nopn_nv", "(", "gen_rtx_REG", "(", "SImode", ",", "127", ")", ")", ",", "hint", ")", ";", "recog_memoized", "(", "insn", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "hint", ")", ";", "}", "insn", "=", "emit_insn_after", "(", "gen_blockage", "(", ")", ",", "hint", ")", ";", "recog_memoized", "(", "insn", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "hint", ")", ";", "if", "(", "CALL_P", "(", "branch", ")", "&&", "distance", "<", "8", "*", "4", ")", "{", "insn", "=", "emit_insn_before", "(", "gen_blockage", "(", ")", ",", "branch", ")", ";", "recog_memoized", "(", "insn", ")", ";", "INSN_LOCATION", "(", "insn", ")", "=", "INSN_LOCATION", "(", "branch", ")", ";", "}", "}", "}", "</s>" ]

[ "Routines", "for", "branch", "hints", "." ]

[ "spu", "0", "0", "0", "0", "600", "1", "1", "0", "1", "0", "0", "1", "1", "0", "0", "1", "588", "8", "4", "8", "4", "4", "127", "8", "4" ]

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"unimplemented operand\"", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "Op", ")", ";", "SDValue", "Op0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Op", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", "||", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "i32", ")", "return", "SDValue", "(", ")", ";", "SDValue", "NewOp0", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_W_X_RV64", ",", "DL", ",", "MVT", "::", "f32", ",", "NewOp0", ")", ";", "return", "FPConv", ";", "}", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "\"unimplemented operand\"", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::BITCAST", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "MVT::i32", "ISD::ANY_EXTEND", "MVT::i64", "RISCVISD::FMV_W_X_RV64", "MVT::f32" ]

[]

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

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

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

[]

[ "<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", "(", ")", "==", "ST", "->", "getAMDGPUAS", "(", ")", ".", "PRIVATE_ADDRESS", ";", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "V", ")", "||", "isa", "<", "AtomicCmpXchgInst", ">", "(", "V", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "V", ")", "||", "isa", "<", "InvokeInst", ">", "(", "V", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::isIntrinsicSourceOfDivergence" ]

[]

[ "<s>", "bool", "mips_hard_regno_rename_ok", "(", "unsigned", "int", "old_reg", "ATTRIBUTE_UNUSED", ",", "unsigned", "int", "new_reg", ")", "{", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", "&&", "!", "df_regs_ever_live_p", "(", "new_reg", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "register", "OLD_REG", "can", "be", "renamed", "to", "register", "NEW_REG", "." ]

[ "mips" ]

[]

[ "<s>", "MachineInstr", "*", "SparcInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FI", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "unsigned", "OpNum", "=", "Ops", "[", "0", "]", ";", "bool", "isFloat", "=", "false", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "SP", "::", "ORrr", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "SP", "::", "G0", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "OpNum", "==", "0", ")", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ";", "else", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "SP", "::", "LDri", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "break", ";", "case", "SP", "::", "FMOVS", ":", "isFloat", "=", "true", ";", "case", "SP", "::", "FMOVD", ":", "if", "(", "OpNum", "==", "0", ")", "{", "unsigned", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "SP", "::", "STFri", ":", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "false", ",", "false", ",", "isKill", ")", ";", "}", "else", "{", "unsigned", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "isFloat", "?", "SP", "::", "LDFri", ":", "SP", "::", "LDDFri", ")", ")", ".", "addReg", "(", "DstReg", ",", "true", ",", "false", ",", "false", ",", "isDead", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "break", ";", "}", "return", "NewMI", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Sparc", "Sparc", "1", "0", "SP::ORrr", "1", "1", "SP::G0", "0", "2", "0", "SP::STri", "0", "2", "SP::LDri", "0", "0", "SP::FMOVS", "SP::FMOVD", "0", "1", "1", "SP::STFri", "SP::STDFri", "0", "0", "0", "SP::LDFri", "SP::LDDFri", "0" ]

[]

[ "<s>", "bool", "XCoreFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", "->", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "bool", "emitFrameMoves", "=", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "*", "MF", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "assert", "(", "Reg", "!=", "XCore", "::", "LR", "&&", "!", "(", "Reg", "==", "XCore", "::", "R10", "&&", "hasFP", "(", "*", "MF", ")", ")", "&&", "\"LR & FP are always handled in emitPrologue\"", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "I", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "auto", "Store", "=", "MI", ";", "--", "Store", ";", "XFI", "->", "getSpillLabels", "(", ")", ".", "push_back", "(", "std", "::", "make_pair", "(", "Store", ",", "I", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::LR", "XCore::R10", "\"LR & FP are always handled in emitPrologue\"" ]

[]

[ "<s>", "PPCTTI", "::", "PopcntSupportKind", "PPCTTI", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "const", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "if", "(", "ST", "->", "hasPOPCNTD", "(", ")", "&&", "TyWidth", "<=", "64", ")", "return", "PSK_FastHardware", ";", "return", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "PowerPC", "PPC", "PPC", "\"Ty width must be power of 2\"", "64" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "0", "1", "0", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "1", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3", "1", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "int", "tilegx_asm_preferred_eh_data_format", "(", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "global", ")", "{", "int", "type", "=", "TARGET_32BIT", "?", "DW_EH_PE_sdata4", ":", "DW_EH_PE_sdata8", ";", "return", "(", "global", "?", "DW_EH_PE_indirect", ":", "0", ")", "|", "DW_EH_PE_pcrel", "|", "type", ";", "}", "</s>" ]

[ "Select", "a", "format", "to", "encode", "pointers", "in", "exception", "handling", "data", ".", "CODE", "is", "0", "for", "data", ",", "1", "for", "code", "labels", ",", "2", "for", "function", "pointers", ".", "GLOBAL", "is", "true", "if", "the", "symbol", "may", "be", "affected", "by", "dynamic", "relocations", "." ]

[ "tilegx", "0" ]

[]

[ "<s>", "unsigned", "CJGInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "CJG", "::", "JMP", "&&", "I", "->", "getOpcode", "(", ")", "!=", "CJG", "::", "JCC", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

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

[ "CJG", "CJG", "\"code size not handled\"", "0", "CJG::JMP", "CJG::JCC" ]

[]

[ "<s>", "static", "bool", "rs6000_builtin_valid_without_lhs", "(", "enum", "rs6000_builtins", "fn_code", ")", "{", "switch", "(", "fn_code", ")", "{", "case", "ALTIVEC_BUILTIN_STVX_V16QI", ":", "case", "ALTIVEC_BUILTIN_STVX_V8HI", ":", "case", "ALTIVEC_BUILTIN_STVX_V4SI", ":", "case", "ALTIVEC_BUILTIN_STVX_V4SF", ":", "case", "ALTIVEC_BUILTIN_STVX_V2DI", ":", "case", "ALTIVEC_BUILTIN_STVX_V2DF", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Helper", "function", "to", "sort", "out", "which", "built-ins", "may", "be", "valid", "without", "having", "a", "LHS", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "cr16_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "int", "ptr_dereference", "=", "0", ";", "switch", "(", "code", ")", "{", "case", "'d'", ":", "{", "const", "char", "*", "cr16_cmp_str", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "EQ", ":", "cr16_cmp_str", "=", "\"eq\"", ";", "break", ";", "case", "NE", ":", "cr16_cmp_str", "=", "\"ne\"", ";", "break", ";", "case", "GT", ":", "cr16_cmp_str", "=", "\"lt\"", ";", "break", ";", "case", "GTU", ":", "cr16_cmp_str", "=", "\"lo\"", ";", "break", ";", "case", "LT", ":", "cr16_cmp_str", "=", "\"gt\"", ";", "break", ";", "case", "LTU", ":", "cr16_cmp_str", "=", "\"hi\"", ";", "break", ";", "case", "GE", ":", "cr16_cmp_str", "=", "\"le\"", ";", "break", ";", "case", "GEU", ":", "cr16_cmp_str", "=", "\"ls\"", ";", "break", ";", "case", "LE", ":", "cr16_cmp_str", "=", "\"ge\"", ";", "break", ";", "case", "LEU", ":", "cr16_cmp_str", "=", "\"hs\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"%s\"", ",", "cr16_cmp_str", ")", ";", "return", ";", "}", "case", "'$'", ":", "putc", "(", "'$'", ",", "file", ")", ";", "return", ";", "case", "'p'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "{", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "return", ";", "}", "break", ";", "case", "'b'", ":", "fprintf", "(", "file", ",", "\"0x%lx\"", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "'r'", ":", "fprintf", "(", "file", ",", "\"%d\"", ",", "cr16_operand_bit_pos", "(", "INTVAL", "(", "x", ")", ",", "0", ")", ")", ";", "return", ";", "case", "'s'", ":", "fprintf", "(", "file", ",", "\"%d\"", ",", "cr16_operand_bit_pos", "(", "INTVAL", "(", "x", ")", ",", "1", ")", ")", ";", "return", ";", "case", "'g'", ":", "ptr_dereference", "=", "1", ";", "case", "'f'", ":", "case", "0", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "if", "(", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "BITS_PER_WORD", ")", "{", "if", "(", "LONG_REG_P", "(", "REGNO", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "else", "fprintf", "(", "file", ",", "\"(%s,%s)\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "+", "1", "]", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "}", "else", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "output_address", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "{", "REAL_VALUE_TYPE", "r", ";", "long", "l", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "r", ",", "l", ")", ";", "fprintf", "(", "file", ",", "\"$0x%lx\"", ",", "l", ")", ";", "return", ";", "}", "case", "CONST_INT", ":", "{", "fprintf", "(", "file", ",", "\"$%ld\"", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "}", "case", "UNSPEC", ":", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "if", "(", "!", "ptr_dereference", ")", "{", "putc", "(", "'$'", ",", "file", ")", ";", "}", "cr16_print_operand_address", "(", "file", ",", "x", ")", ";", "return", ";", "}", "default", ":", "output_operand_lossage", "(", "\"invalid %%xn code\"", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "PRINT_OPERAND", "defined", "in", "cr16.h", "." ]

[ "cr16", "0", "\"eq\"", "\"ne\"", "\"lt\"", "\"lo\"", "\"gt\"", "\"hi\"", "\"le\"", "\"ls\"", "\"ge\"", "\"hs\"", "\"%s\"", "\"%s\"", "\"0x%lx\"", "\"%d\"", "0", "\"%d\"", "1", "1", "0", "\"(%s)\"", "\"(%s,%s)\"", "1", "\"%s\"", "0", "\"$0x%lx\"", "\"$%ld\"", "1", "\"invalid %%xn code\"" ]

[]

[ "<s>", "void", "HSAILInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "HSAIL", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "HSAIL", "::", "MOV_B32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "BRIG_TYPE_B32", ")", ";", "return", ";", "}", "if", "(", "HSAIL", "::", "GPR64RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "HSAIL", "::", "MOV_B64", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "BRIG_TYPE_B64", ")", ";", "return", ";", "}", "if", "(", "HSAIL", "::", "CRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "HSAIL", "::", "MOV_B1", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "BRIG_TYPE_B1", ")", ";", "return", ";", "}", "unsigned", "SrcBT", "=", "-", "1", ";", "unsigned", "DestBT", "=", "-", "1", ";", "unsigned", "CvtOpc", "=", "-", "1", ";", "if", "(", "HSAIL", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", "&&", "HSAIL", "::", "CRRegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "DestBT", "=", "BRIG_TYPE_B1", ";", "SrcBT", "=", "BRIG_TYPE_U32", ";", "CvtOpc", "=", "HSAIL", "::", "CVT_B1_U32", ";", "}", "else", "if", "(", "HSAIL", "::", "CRRegClass", ".", "contains", "(", "DestReg", ")", "&&", "HSAIL", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "DestBT", "=", "BRIG_TYPE_U32", ";", "SrcBT", "=", "BRIG_TYPE_B1", ";", "CvtOpc", "=", "HSAIL", "::", "CVT_U32_B1", ";", "}", "else", "if", "(", "HSAIL", "::", "GPR64RegClass", ".", "contains", "(", "DestReg", ")", "&&", "HSAIL", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "DestBT", "=", "BRIG_TYPE_U32", ";", "SrcBT", "=", "BRIG_TYPE_U64", ";", "CvtOpc", "=", "HSAIL", "::", "CVT_U32_U64", ";", "}", "else", "if", "(", "HSAIL", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", "&&", "HSAIL", "::", "GPR64RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "DestBT", "=", "BRIG_TYPE_U64", ";", "SrcBT", "=", "BRIG_TYPE_U32", ";", "CvtOpc", "=", "HSAIL", "::", "CVT_U64_U32", ";", "}", "else", "{", "assert", "(", "!", "\"When do we hit this?\"", ")", ";", "return", "TargetInstrInfo", "::", "copyPhysReg", "(", "MBB", ",", "MI", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "CvtOpc", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "DestBT", ")", ".", "addImm", "(", "SrcBT", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "HSAIL::GPR32RegClass", "HSAIL::MOV_B32", "HSAIL::GPR64RegClass", "HSAIL::MOV_B64", "HSAIL::CRRegClass", "HSAIL::MOV_B1", "1", "1", "1", "HSAIL::GPR32RegClass", "HSAIL::CRRegClass", "HSAIL::CVT_B1_U32", "HSAIL::CRRegClass", "HSAIL::GPR32RegClass", "HSAIL::CVT_U32_B1", "HSAIL::GPR64RegClass", "HSAIL::GPR32RegClass", "HSAIL::CVT_U32_U64", "HSAIL::GPR32RegClass", "HSAIL::GPR64RegClass", "HSAIL::CVT_U64_U32", "\"When do we hit this?\"", "0", "0" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValue1SImm16", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "FixupExpression", "=", "MCBinaryExpr", "::", "createAdd", "(", "MO", ".", "getExpr", "(", ")", ",", "MCConstantExpr", "::", "create", "(", "-", "4", ",", "Ctx", ")", ",", "Ctx", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "FixupExpression", ",", "MCFixupKind", "(", "Mips", "::", "fixup_Mips_PC16", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValue1SImm16", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "1", "\"getBranchTargetOpValue expects only expressions or immediates\"", "4", "0", "Mips::fixup_Mips_PC16", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "return", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_X86", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::OutputArg", "16", "X86" ]

[]

[ "<s>", "static", "rtx", "frv_expand_unop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ",", "rtx", "target", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "target", "=", "frv_legitimize_target", "(", "icode", ",", "target", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "op0", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "one", "operand", "." ]

[ "frv", "0", "1" ]

[]

[ "<s>", "void", "SNESAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "adjustFixupValue", "(", "Fixup", ",", "Target", ",", "Value", ",", "&", "Asm", ".", "getContext", "(", ")", ")", ";", "if", "(", "Value", "==", "0", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "auto", "NumBits", "=", "Info", ".", "TargetSize", "+", "Info", ".", "TargetOffset", ";", "auto", "NumBytes", "=", "(", "NumBits", "/", "8", ")", "+", "(", "(", "NumBits", "%", "8", ")", "==", "0", "?", "0", ":", "1", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumBytes", ";", "++", "i", ")", "{", "uint8_t", "mask", "=", "(", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "mask", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "SNES", "SNES", "0", "8", "8", "0", "0", "1", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "static", "rtx", "loongarch_unspec_address_offset", "(", "rtx", "base", ",", "rtx", "offset", ",", "enum", "loongarch_symbol_type", "symbol_type", ")", "{", "base", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "base", ")", ",", "UNSPEC_ADDRESS_FIRST", "+", "symbol_type", ")", ";", "if", "(", "offset", "!=", "const0_rtx", ")", "base", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "return", "gen_rtx_CONST", "(", "Pmode", ",", "base", ")", ";", "}", "</s>" ]

[ "Wrap", "symbol", "or", "label", "BASE", "in", "an", "UNSPEC", "address", "of", "type", "SYMBOL_TYPE", ",", "then", "add", "CONST_INT", "OFFSET", "to", "the", "result", "." ]

[ "loongarch", "1" ]

[]

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

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

[ "NVPTX", "NVPTX" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "(", "Amount", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "assert", "(", "Amount", "%", "4", "==", "0", ")", ";", "Amount", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "Amount", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "Amount", ")", ")", "{", "errs", "(", ")", "<<", "\"eliminateCallFramePseudoInstr size too big: \"", "<<", "Amount", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "0", ")", ";", "}", "MachineInstr", "*", "New", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKDOWN", ")", "{", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "EXTSP_u6", ":", "XCore", "::", "EXTSP_lu6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "XCore", "::", "ADJCALLSTACKUP", ")", ";", "int", "Opcode", "=", "isU6", "?", "XCore", "::", "LDAWSP_ru6", ":", "XCore", "::", "LDAWSP_lru6", ";", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "0", "0", "1", "4", "0", "4", "\"eliminateCallFramePseudoInstr size too big: \"", "\"\\n\"", "0", "XCore::ADJCALLSTACKDOWN", "XCore::EXTSP_u6", "XCore::EXTSP_lu6", "XCore::ADJCALLSTACKUP", "XCore::LDAWSP_ru6", "XCore::LDAWSP_lru6", "XCore::SP" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_JT", ":", "return", "lowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "lowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "lowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "lowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCOPYSIGN", ":", "return", "lowerFCOPYSIGN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "return", "lowerFABS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "lowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "return", "lowerShiftRightParts", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "lowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "lowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "lowerADD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "lowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::BR_JT", "ISD::BRCOND", "ISD::ConstantPool", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::FCOPYSIGN", "ISD::FABS", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::ATOMIC_FENCE", "ISD::SHL_PARTS", "ISD::SRA_PARTS", "ISD::SRL_PARTS", "ISD::LOAD", "ISD::STORE", "ISD::ADD", "ISD::FP_TO_SINT" ]

[]

[ "<s>", "void", "MipsSEFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "MipsSEInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MipsSEInstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "unsigned", "SP", "=", "STI", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "SP_64", ":", "Mips", "::", "SP", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "0", "Mips::ADJCALLSTACKDOWN", "Mips::SP_64", "Mips::SP" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "static", "void", "mips_annotate_pic_call_expr", "(", "rtx", "call", ",", "rtx", "symbol", ")", "{", "rtx", "args_size", ";", "args_size", "=", "XEXP", "(", "call", ",", "1", ")", ";", "XEXP", "(", "call", ",", "1", ")", "=", "gen_rtx_UNSPEC", "(", "GET_MODE", "(", "args_size", ")", ",", "gen_rtvec", "(", "2", ",", "args_size", ",", "symbol", ")", ",", "UNSPEC_CALL_ATTR", ")", ";", "}", "</s>" ]

[ "Replace", "the", "args_size", "operand", "of", "the", "call", "expression", "CALL", "with", "the", "call-attribute", "UNSPEC", "and", "fill", "in", "SYMBOL", "as", "the", "function", "symbol", "." ]

[ "mips", "1", "1", "2" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cum", ";", "tree", "param", ",", "next_param", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "{", "fprintf", "(", "stderr", ",", "\"\\ninit_cumulative_args (\"", ")", ";", "if", "(", "fntype", ")", "fprintf", "(", "stderr", ",", "\"fntype code = %s, ret code = %s\"", ",", "tree_code_name", "[", "(", "int", ")", "TREE_CODE", "(", "fntype", ")", "]", ",", "tree_code_name", "[", "(", "int", ")", "TREE_CODE", "(", "TREE_TYPE", "(", "fntype", ")", ")", "]", ")", ";", "else", "fprintf", "(", "stderr", ",", "\"no fntype\"", ")", ";", "if", "(", "libname", ")", "fprintf", "(", "stderr", ",", "\", libname = %s\"", ",", "XSTR", "(", "libname", ",", "0", ")", ")", ";", "}", "*", "cum", "=", "zero_cum", ";", "cum", "->", "nregs", "=", "ix86_regparm", ";", "if", "(", "TARGET_SSE", ")", "cum", "->", "sse_nregs", "=", "SSE_REGPARM_MAX", ";", "if", "(", "TARGET_MMX", ")", "cum", "->", "mmx_nregs", "=", "MMX_REGPARM_MAX", ";", "cum", "->", "warn_sse", "=", "true", ";", "cum", "->", "warn_mmx", "=", "true", ";", "cum", "->", "maybe_vaarg", "=", "false", ";", "if", "(", "fntype", "&&", "!", "TARGET_64BIT", ")", "{", "if", "(", "lookup_attribute", "(", "\"fastcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "{", "cum", "->", "nregs", "=", "2", ";", "cum", "->", "fastcall", "=", "1", ";", "}", "else", "cum", "->", "nregs", "=", "ix86_function_regparm", "(", "fntype", ",", "fndecl", ")", ";", "}", "cum", "->", "float_in_sse", "=", "ix86_function_sseregparm", "(", "fntype", ",", "fndecl", ")", ";", "if", "(", "cum", "->", "nregs", "||", "cum", "->", "mmx_nregs", "||", "cum", "->", "sse_nregs", ")", "{", "for", "(", "param", "=", "(", "fntype", ")", "?", "TYPE_ARG_TYPES", "(", "fntype", ")", ":", "0", ";", "param", "!=", "0", ";", "param", "=", "next_param", ")", "{", "next_param", "=", "TREE_CHAIN", "(", "param", ")", ";", "if", "(", "next_param", "==", "0", "&&", "TREE_VALUE", "(", "param", ")", "!=", "void_type_node", ")", "{", "if", "(", "!", "TARGET_64BIT", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "sse_nregs", "=", "0", ";", "cum", "->", "mmx_nregs", "=", "0", ";", "cum", "->", "warn_sse", "=", "0", ";", "cum", "->", "warn_mmx", "=", "0", ";", "cum", "->", "fastcall", "=", "0", ";", "cum", "->", "float_in_sse", "=", "0", ";", "}", "cum", "->", "maybe_vaarg", "=", "true", ";", "}", "}", "}", "if", "(", "(", "!", "fntype", "&&", "!", "libname", ")", "||", "(", "fntype", "&&", "!", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "cum", "->", "maybe_vaarg", "=", "true", ";", "if", "(", "TARGET_DEBUG_ARG", ")", "fprintf", "(", "stderr", ",", "\", nregs=%d )\\n\"", ",", "cum", "->", "nregs", ")", ";", "return", ";", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "i386", "\"\\ninit_cumulative_args (\"", "\"fntype code = %s, ret code = %s\"", "\"no fntype\"", "\", libname = %s\"", "0", "\"fastcall\"", "2", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "\", nregs=%d )\\n\"" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "Out", ")", "const", "{", "R", ".", "print", "(", "Out", ")", ";", "Out", "<<", "\", Matched=\"", "<<", "Matched", ";", "}", "</s>" ]

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

[ "Mips", "\", Matched=\"" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "PseudoSourceValue", "*", "V", ")", "{", "return", "V", "->", "kind", "(", ")", "==", "GWSResource", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "MipsCallEntry", "::", "isConstant", "(", "const", "MachineFrameInfo", "*", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "we", "know", "the", "value", "of", "all", "bits", "." ]

[ "Mips", "Mips" ]

[]

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

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "VE" ]

[]

[ "<s>", "rtx", "alpha_use_linkage", "(", "rtx", "func", ",", "bool", "lflag", ",", "bool", "rflag", ")", "{", "struct", "alpha_links", "*", "al", "=", "NULL", ";", "const", "char", "*", "name", "=", "XSTR", "(", "func", ",", "0", ")", ";", "if", "(", "cfun", "->", "machine", "->", "links", ")", "{", "alpha_links", "*", "*", "slot", "=", "cfun", "->", "machine", "->", "links", "->", "get", "(", "name", ")", ";", "if", "(", "slot", ")", "al", "=", "*", "slot", ";", "}", "else", "cfun", "->", "machine", "->", "links", "=", "hash_map", "<", "const", "char", "*", ",", "alpha_links", "*", ",", "string_traits", ">", "::", "create_ggc", "(", "64", ")", ";", "if", "(", "al", "==", "NULL", ")", "{", "size_t", "buf_len", ";", "char", "*", "linksym", ";", "tree", "id", ";", "if", "(", "name", "[", "0", "]", "==", "'*'", ")", "name", "++", ";", "id", "=", "maybe_get_identifier", "(", "name", ")", ";", "if", "(", "id", ")", "{", "while", "(", "IDENTIFIER_TRANSPARENT_ALIAS", "(", "id", ")", ")", "id", "=", "TREE_CHAIN", "(", "id", ")", ";", "name", "=", "IDENTIFIER_POINTER", "(", "id", ")", ";", "}", "buf_len", "=", "strlen", "(", "name", ")", "+", "8", "+", "9", ";", "linksym", "=", "(", "char", "*", ")", "alloca", "(", "buf_len", ")", ";", "snprintf", "(", "linksym", ",", "buf_len", ",", "\"$%d..%s..lk\"", ",", "cfun", "->", "funcdef_no", ",", "name", ")", ";", "al", "=", "ggc_alloc", "<", "alpha_links", ">", "(", ")", ";", "al", "->", "func", "=", "func", ";", "al", "->", "linkage", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "linksym", ")", ")", ";", "cfun", "->", "machine", "->", "links", "->", "put", "(", "ggc_strdup", "(", "name", ")", ",", "al", ")", ";", "}", "al", "->", "rkind", "=", "rflag", "?", "KIND_CODEADDR", ":", "KIND_LINKAGE", ";", "if", "(", "lflag", ")", "return", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "al", "->", "linkage", ",", "8", ")", ")", ";", "else", "return", "al", "->", "linkage", ";", "}", "</s>" ]

[ "Return", "a", "SYMBOL_REF", "representing", "the", "reference", "to", "the", ".linkage", "entry", "of", "function", "FUNC", "built", "for", "calls", "made", "from", "CFUNDECL", ".", "LFLAG", "is", "1", "if", "this", "is", "the", "reference", "to", "the", "linkage", "pointer", "value", ",", "0", "if", "this", "is", "the", "reference", "to", "the", "function", "entry", "value", ".", "RFLAG", "is", "1", "if", "this", "a", "reduced", "reference", "(", "code", "address", "only", ")", ",", "0", "if", "this", "is", "a", "full", "reference", "." ]

[ "alpha", "0", "64", "0", "8", "9", "\"$%d..%s..lk\"", "8" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "auto", "E", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "E", ")", "return", "false", ";", "while", "(", "I", "!=", "E", "&&", "!", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isReturn", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_MASK_BRANCH", ":", "case", "AMDGPU", "::", "S_MOV_B64_term", ":", "case", "AMDGPU", "::", "S_XOR_B64_term", ":", "case", "AMDGPU", "::", "S_OR_B64_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B64_term", ":", "case", "AMDGPU", "::", "S_MOV_B32_term", ":", "case", "AMDGPU", "::", "S_XOR_B32_term", ":", "case", "AMDGPU", "::", "S_OR_B32_term", ":", "case", "AMDGPU", "::", "S_ANDN2_B32_term", ":", "break", ";", "case", "AMDGPU", "::", "SI_IF", ":", "case", "AMDGPU", "::", "SI_ELSE", ":", "case", "AMDGPU", "::", "SI_KILL_I1_TERMINATOR", ":", "case", "AMDGPU", "::", "SI_KILL_F32_COND_IMM_TERMINATOR", ":", "return", "true", ";", "default", ":", "llvm_unreachable", "(", "\"unexpected non-branch terminator inst\"", ")", ";", "}", "++", "I", ";", "}", "if", "(", "I", "==", "E", ")", "return", "false", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "SI_MASK_BRANCH", ")", "return", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ";", "++", "I", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "true", ";", "if", "(", "analyzeBranchImpl", "(", "MBB", ",", "I", ",", "TBB", ",", "FBB", ",", "Cond", ",", "AllowModify", ")", ")", "return", "true", ";", "MachineBasicBlock", "*", "MaskBrDest", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "if", "(", "TBB", "!=", "MaskBrDest", "||", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "auto", "Pred", "=", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "return", "(", "Pred", "!=", "EXECZ", "&&", "Pred", "!=", "EXECNZ", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::SI_MASK_BRANCH", "AMDGPU::S_MOV_B64_term", "AMDGPU::S_XOR_B64_term", "AMDGPU::S_OR_B64_term", "AMDGPU::S_ANDN2_B64_term", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_XOR_B32_term", "AMDGPU::S_OR_B32_term", "AMDGPU::S_ANDN2_B32_term", "AMDGPU::SI_IF", "AMDGPU::SI_ELSE", "AMDGPU::SI_KILL_I1_TERMINATOR", "AMDGPU::SI_KILL_F32_COND_IMM_TERMINATOR", "\"unexpected non-branch terminator inst\"", "AMDGPU::SI_MASK_BRANCH", "0", "0" ]

[]

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

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

[ "RISCV" ]

[]

[ "<s>", "static", "bool", "avr_warn_func_return", "(", "tree", "decl", ")", "{", "return", "!", "avr_naked_function_p", "(", "decl", ")", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_WARN_FUNC_RETURN", "'", "." ]

[ "avr" ]

[]

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

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

[ "AMDGPU", "SI", "7", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16", "1", "8" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be reloaded into\"", ")", ";", "assert", "(", "DestReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "DestReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "DestReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "hasAGPRs", "(", "RC", ")", "?", "getAGPRSpillRestoreOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillRestoreOpcode", "(", "SpillSize", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "RC", ")", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "Tmp", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ")", ";", "MIB", ".", "addReg", "(", "Tmp", ",", "RegState", "::", "Define", ")", ";", "}", "MIB", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be reloaded into\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "AMDGPU::VGPR_32RegClass", "0" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "return", "RISCV", "::", "X11", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "typeid", "on", "entry", "to", "a", "landing", "pad", "." ]

[ "RISCV", "RISCV", "RISCV::X11" ]

[]