Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "virtual", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "Register", "HexagonRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "HexagonFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "return", "getFrameRegister", "(", ")", ";", "return", "getStackRegister", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "loongarch_emit_probe_stack_range", "(", "HOST_WIDE_INT", "first", ",", "HOST_WIDE_INT", "size", ")", "{", "HOST_WIDE_INT", "rounded_size", ";", "HOST_WIDE_INT", "interval", ";", "if", "(", "flag_stack_clash_protection", ")", "interval", "=", "STACK_CLASH_PROTECTION_GUARD_SIZE", ";", "else", "interval", "=", "PROBE_INTERVAL", ";", "rtx", "r12", "=", "LARCH_PROLOGUE_TEMP2", "(", "Pmode", ")", ";", "rtx", "r14", "=", "LARCH_PROLOGUE_TEMP3", "(", "Pmode", ")", ";", "size", "=", "size", "+", "first", ";", "gcc_assert", "(", "first", "<=", "16384", ")", ";", "rounded_size", "=", "ROUND_DOWN", "(", "size", ",", "interval", ")", ";", "emit_move_insn", "(", "r14", ",", "GEN_INT", "(", "interval", ")", ")", ";", "if", "(", "rounded_size", "!=", "0", ")", "{", "if", "(", "rounded_size", "<=", "STACK_CLASH_MAX_UNROLL_PAGES", "*", "interval", ")", "{", "for", "(", "HOST_WIDE_INT", "i", "=", "0", ";", "i", "<", "rounded_size", ";", "i", "+=", "interval", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "r14", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "const0_rtx", ")", ")", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "dump_stack_clash_frame_info", "(", "PROBE_INLINE", ",", "size", "!=", "rounded_size", ")", ";", "}", "else", "{", "emit_move_insn", "(", "r12", ",", "GEN_INT", "(", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "r12", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "r12", ")", ")", ")", ";", "emit_insn", "(", "gen_probe_stack_range", "(", "Pmode", ",", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "r12", ",", "r14", ")", ")", ";", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "dump_stack_clash_frame_info", "(", "PROBE_LOOP", ",", "size", "!=", "rounded_size", ")", ";", "}", "}", "else", "dump_stack_clash_frame_info", "(", "NO_PROBE_SMALL_FRAME", ",", "true", ")", ";", "if", "(", "size", "!=", "rounded_size", ")", "{", "if", "(", "size", "-", "rounded_size", ">=", "2048", ")", "{", "emit_move_insn", "(", "r14", ",", "GEN_INT", "(", "size", "-", "rounded_size", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_MINUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "r14", ")", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "rounded_size", "-", "size", ")", ")", ")", ")", ";", "}", "if", "(", "first", ")", "{", "emit_move_insn", "(", "r12", ",", "GEN_INT", "(", "first", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "r12", ")", ")", ")", ";", "}", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "probe", "a", "range", "of", "stack", "addresses", "from", "FIRST", "to", "FIRST+SIZE", ",", "inclusive", ".", "These", "are", "offsets", "from", "the", "current", "stack", "pointer", "." ]

[ "loongarch", "16384", "0", "0", "2048" ]

[]

[ "<s>", "static", "bool", "riscv_valid_lo_sum_p", "(", "enum", "riscv_symbol_type", "sym_type", ",", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "int", "align", ",", "size", ";", "if", "(", "riscv_symbol_insns", "(", "sym_type", ")", "==", "0", ")", "return", "false", ";", "if", "(", "!", "riscv_split_symbol_type", "(", "sym_type", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "rtx", "offset", ";", "split_const", "(", "x", ",", "&", "x", ",", "&", "offset", ")", ";", "if", "(", "!", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "false", ";", "align", "=", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "DECL_ALIGN", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "1", ")", ";", "size", "=", "(", "SYMBOL_REF_DECL", "(", "x", ")", "&&", "DECL_SIZE", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", "?", "tree_to_uhwi", "(", "DECL_SIZE", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ")", ":", "2", "*", "BITS_PER_WORD", ")", ";", "}", "else", "{", "align", "=", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "size", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "}", "if", "(", "size", ">", "BITS_PER_WORD", "&&", "(", "!", "TARGET_STRICT_ALIGN", "||", "size", ">", "align", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "LO_SUM", "can", "address", "a", "value", "of", "mode", "MODE", "when", "the", "LO_SUM", "symbol", "has", "type", "SYM_TYPE", "." ]

[ "riscv", "0", "1", "2" ]

[]

[ "<s>", "static", "void", "aarch64_pushwb_single_reg", "(", "machine_mode", "mode", ",", "unsigned", "regno", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "rtx", "base_rtx", "=", "stack_pointer_rtx", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "mem", "=", "gen_rtx_PRE_MODIFY", "(", "Pmode", ",", "base_rtx", ",", "plus_constant", "(", "Pmode", ",", "base_rtx", ",", "-", "adjustment", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "mem", ")", ";", "insn", "=", "emit_move_insn", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Push", "the", "register", "number", "REGNO", "of", "mode", "MODE", "to", "the", "stack", "with", "write-back", "adjusting", "the", "stack", "by", "ADJUSTMENT", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "getDataLayout", "(", ")", ".", "getPointerSizeInBits", "(", ")", "==", "64", ";", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "if", "(", "MMI", ")", "{", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", ")", "{", "for", "(", "const", "Function", "*", "Personality", ":", "MMI", "->", "getPersonalities", "(", ")", ")", "{", "if", "(", "Personality", ")", "{", "MCSymbol", "*", "NLPSym", "=", "getSymbolWithGlobalValueBase", "(", "Personality", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "Personality", ")", ",", "true", ")", ";", "}", "}", "}", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", "->", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", "->", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", "->", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "else", "OutStreamer", "->", "EmitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "}", "OutStreamer", "->", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "PPC", "8", "4" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVector", "<", "ISD", "::", "OutputArg", ",", "32", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVector", "<", "SDValue", ",", "32", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVector", "<", "ISD", "::", "InputArg", ",", "32", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "XCore", "XCore", "ISD::OutputArg", "32", "32", "ISD::InputArg", "32", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "bool", "X86AvoidTrailingCallPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "const", "X86InstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "STI", ".", "isTargetWin64", "(", ")", "&&", "\"pass only runs on Win64\"", ")", ";", "if", "(", "!", "MF", ".", "hasWinCFI", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "MachineBasicBlock", "*", "NextMBB", "=", "MBB", ".", "getNextNode", "(", ")", ";", "if", "(", "NextMBB", "&&", "!", "NextMBB", "->", "isEHFuncletEntry", "(", ")", ")", "continue", ";", "auto", "LastRealInstr", "=", "llvm", "::", "find_if", "(", "reverse", "(", "MBB", ")", ",", "isRealInstruction", ")", ";", "bool", "IsEmpty", "=", "LastRealInstr", "==", "MBB", ".", "rend", "(", ")", ";", "bool", "IsCall", "=", "!", "IsEmpty", "&&", "isCallInstruction", "(", "*", "LastRealInstr", ")", ";", "if", "(", "IsEmpty", "||", "IsCall", ")", "{", "LLVM_DEBUG", "(", "{", "if", "(", "IsCall", ")", "{", "dbgs", "(", ")", "<<", "\"inserting int3 after trailing call instruction:\\n\"", ";", "LastRealInstr", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "\"inserting int3 in trailing empty MBB:\\n\"", ";", "MBB", ".", "dump", "(", ")", ";", "}", "}", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "IsCall", ")", "{", "MBBI", "=", "std", "::", "next", "(", "LastRealInstr", ".", "getReverse", "(", ")", ")", ";", "DL", "=", "LastRealInstr", "->", "getDebugLoc", "(", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "INT3", ")", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "\"pass only runs on Win64\"", "\"inserting int3 after trailing call instruction:\\n\"", "\"inserting int3 in trailing empty MBB:\\n\"", "X86::INT3" ]

[]

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

[ "Implement", "TARGET_HARD_REGNO_MODE_OK", "." ]

[ "xtensa" ]

[]

[ "<s>", "bool", "ARMLegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "MIRBuilder", ")", "const", "{", "using", "namespace", "TargetOpcode", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "G_SDIV", ":", "case", "G_UDIV", ":", "{", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "Ty", "!=", "LLT", "::", "scalar", "(", "16", ")", "&&", "Ty", "!=", "LLT", "::", "scalar", "(", "8", ")", ")", "return", "false", ";", "LegalizerHelper", "Helper", "(", "MIRBuilder", ".", "getMF", "(", ")", ")", ";", "MachineInstr", "*", "NewMI", "=", "nullptr", ";", "Helper", ".", "MIRBuilder", ".", "recordInsertions", "(", "[", "&", "]", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "G_SDIV", "||", "MI", "->", "getOpcode", "(", ")", "==", "G_UDIV", ")", "NewMI", "=", "MI", ";", "}", ")", ";", "auto", "Result", "=", "Helper", ".", "widenScalar", "(", "MI", ",", "0", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "Helper", ".", "MIRBuilder", ".", "stopRecordingInsertions", "(", ")", ";", "if", "(", "Result", "==", "LegalizerHelper", "::", "UnableToLegalize", ")", "{", "return", "false", ";", "}", "assert", "(", "NewMI", "&&", "\"Couldn't find widened instruction\"", ")", ";", "assert", "(", "(", "NewMI", "->", "getOpcode", "(", ")", "==", "G_SDIV", "||", "NewMI", "->", "getOpcode", "(", ")", "==", "G_UDIV", ")", "&&", "\"Unexpected widened instruction\"", ")", ";", "assert", "(", "MRI", ".", "getType", "(", "NewMI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "getSizeInBits", "(", ")", "==", "32", "&&", "\"Unexpected type for the widened instruction\"", ")", ";", "Result", "=", "Helper", ".", "legalizeInstrStep", "(", "*", "NewMI", ")", ";", "if", "(", "Result", "==", "LegalizerHelper", "::", "UnableToLegalize", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "case", "G_SREM", ":", "case", "G_UREM", ":", "{", "unsigned", "OriginalResult", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "auto", "Size", "=", "MRI", ".", "getType", "(", "OriginalResult", ")", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "!=", "32", ")", "return", "false", ";", "auto", "Libcall", "=", "MI", ".", "getOpcode", "(", ")", "==", "G_SREM", "?", "RTLIB", "::", "SDIVREM_I32", ":", "RTLIB", "::", "UDIVREM_I32", ";", "auto", "&", "Ctx", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Type", "*", "ArgTy", "=", "Type", "::", "getInt32Ty", "(", "Ctx", ")", ";", "StructType", "*", "RetTy", "=", "StructType", "::", "get", "(", "Ctx", ",", "{", "ArgTy", ",", "ArgTy", "}", ",", "true", ")", ";", "auto", "RetVal", "=", "MRI", ".", "createGenericVirtualRegister", "(", "getLLTForType", "(", "*", "RetTy", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getDataLayout", "(", ")", ")", ")", ";", "auto", "Status", "=", "replaceWithLibcall", "(", "MI", ",", "MIRBuilder", ",", "Libcall", ",", "{", "RetVal", ",", "RetTy", "}", ",", "{", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "ArgTy", "}", ",", "{", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "ArgTy", "}", "}", ")", ";", "if", "(", "Status", "!=", "LegalizerHelper", "::", "Legalized", ")", "return", "false", ";", "MIRBuilder", ".", "buildUnmerge", "(", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ",", "OriginalResult", "}", ",", "RetVal", ")", ";", "return", "LegalizerHelper", "::", "Legalized", ";", "}", "}", "}", "</s>" ]

[ "Called", "for", "instructions", "with", "the", "Custom", "LegalizationAction", "." ]

[ "ARM", "ARM", "0", "16", "8", "0", "32", "\"Couldn't find widened instruction\"", "\"Unexpected widened instruction\"", "0", "32", "\"Unexpected type for the widened instruction\"", "0", "32", "1", "2", "32" ]

[]

[ "<s>", "static", "reg_class_t", "pdp11_secondary_reload", "(", "bool", "in_p", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "reg_class_t", "reload_class", ",", "machine_mode", "reload_mode", "ATTRIBUTE_UNUSED", ",", "secondary_reload_info", "*", "sri", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "reload_class", "!=", "NO_LOAD_FPU_REGS", "||", "GET_CODE", "(", "x", ")", "!=", "REG", "||", "REGNO_REG_CLASS", "(", "REGNO", "(", "x", ")", ")", "==", "LOAD_FPU_REGS", ")", "return", "NO_REGS", ";", "return", "LOAD_FPU_REGS", ";", "}", "</s>" ]

[ "TARGET_SECONDARY_RELOAD", ".", "FPU", "registers", "AC4", "and", "AC5", "(", "class", "NO_LOAD_FPU_REGS", ")", "require", "an", "intermediate", "register", "(", "AC0-AC3", ":", "LOAD_FPU_REGS", ")", ".", "Everything", "else", "can", "be", "loade/stored", "directly", "." ]

[ "pdp11" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "getTgtMemIntrinsic", "(", "IntrinsicInst", "*", "Inst", ",", "MemIntrinsicInfo", "&", "Info", ")", "const", "{", "switch", "(", "Inst", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "auto", "*", "Ordering", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "2", ")", ")", ";", "auto", "*", "Volatile", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "Inst", "->", "getArgOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Ordering", "||", "!", "Volatile", ")", "return", "false", ";", "unsigned", "OrderingVal", "=", "Ordering", "->", "getZExtValue", "(", ")", ";", "if", "(", "OrderingVal", ">", "static_cast", "<", "unsigned", ">", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ")", "return", "false", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "0", ")", ";", "Info", ".", "Ordering", "=", "static_cast", "<", "AtomicOrdering", ">", "(", "OrderingVal", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "true", ";", "Info", ".", "IsVolatile", "=", "!", "Volatile", "->", "isZero", "(", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_ordered_add", "Intrinsic::amdgcn_ds_ordered_swap", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "2", "4", "0" ]

[]

[ "<s>", "virtual", "int", "getOperandLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "SDNode", "*", "DefNode", ",", "unsigned", "DefIdx", ",", "SDNode", "*", "UseNode", ",", "unsigned", "UseIdx", ")", "const", "{", "return", "PPCGenInstrInfo", "::", "getOperandLatency", "(", "ItinData", ",", "DefNode", ",", "DefIdx", ",", "UseNode", ",", "UseIdx", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "PPCTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createPPCBranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "tilepro_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "type", "&&", "TYPE_SIZE", "(", "type", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "!=", "INTEGER_CST", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PASS_BY_REFERENCE", ".", "Variable", "sized", "types", "are", "passed", "by", "reference", "." ]

[ "tilepro" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Optimize Returned\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Optimize Returned\"" ]

[]

[ "<s>", "bool", "Thumb2SizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "PredicateFtor", "&&", "!", "PredicateFtor", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "STI", "->", "isThumb1Only", "(", ")", "||", "STI", "->", "prefers32BitThumb", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", "->", "getInstrInfo", "(", ")", ")", ";", "OptimizeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "optForSize", "(", ")", ";", "MinimizeSize", "=", "MF", ".", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "BlockInfo", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "RPOT", "(", "&", "MF", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "ReversePostOrderTraversal", "<", "MachineFunction", "*", ">", "::", "rpo_iterator", "I", "=", "RPOT", ".", "begin", "(", ")", ",", "E", "=", "RPOT", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "MachineInstr", "*", "RISCVInstrInfo", "::", "convertToThreeAddress", "(", "MachineFunction", "::", "iterator", "&", "MBB", ",", "MachineInstr", "&", "MI", ",", "LiveVariables", "*", "LV", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "CASE_WIDEOP_OPCODE_LMULS", "(", "FWADD_WV", ")", ":", "case", "CASE_WIDEOP_OPCODE_LMULS", "(", "FWSUB_WV", ")", ":", "case", "CASE_WIDEOP_OPCODE_LMULS", "(", "WADD_WV", ")", ":", "case", "CASE_WIDEOP_OPCODE_LMULS", "(", "WADDU_WV", ")", ":", "case", "CASE_WIDEOP_OPCODE_LMULS", "(", "WSUB_WV", ")", ":", "case", "CASE_WIDEOP_OPCODE_LMULS", "(", "WSUBU_WV", ")", ":", "{", "unsigned", "NewOpc", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected opcode\"", ")", ";", "CASE_WIDEOP_CHANGE_OPCODE_LMULS", "(", "FWADD_WV", ")", "CASE_WIDEOP_CHANGE_OPCODE_LMULS", "(", "FWSUB_WV", ")", "CASE_WIDEOP_CHANGE_OPCODE_LMULS", "(", "WADD_WV", ")", "CASE_WIDEOP_CHANGE_OPCODE_LMULS", "(", "WADDU_WV", ")", "CASE_WIDEOP_CHANGE_OPCODE_LMULS", "(", "WSUB_WV", ")", "CASE_WIDEOP_CHANGE_OPCODE_LMULS", "(", "WSUBU_WV", ")", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpc", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "2", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "4", ")", ")", ";", "MIB", ".", "copyImplicitOps", "(", "MI", ")", ";", "if", "(", "LV", ")", "{", "unsigned", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "for", "(", "unsigned", "I", "=", "1", ";", "I", "<", "NumOps", ";", "++", "I", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isKill", "(", ")", ")", "LV", "->", "replaceKillInstruction", "(", "Op", ".", "getReg", "(", ")", ",", "MI", ",", "*", "MIB", ")", ";", "}", "}", "return", "MIB", ";", "}", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "convertToThreeAddress", "-", "This", "method", "must", "be", "implemented", "by", "targets", "that", "set", "the", "M_CONVERTIBLE_TO_3_ADDR", "flag", "." ]

[ "RISCV", "RISCV", "\"Unexpected opcode\"", "0", "1", "2", "3", "4", "1" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "Kind", "==", "k_Register", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "ARM64", "\"Invalid access!\"" ]

[]

[ "<s>", "unsigned", "OR1KRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "OR1K", "::", "R2", ":", "OR1K", "::", "R1", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "OR1K::R2", "OR1K::R1" ]

[]

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

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

[ "ARCompact", "ARC" ]

[]

[ "<s>", "void", "mt_final_prescan_insn", "(", "rtx", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "prev_i", ";", "enum", "attr_type", "prev_attr", ";", "mt_nops_required", "=", "0", ";", "mt_nop_reasons", "=", "\"\"", ";", "if", "(", "TARGET_MS2", ")", "return", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", ";", "for", "(", "prev_i", "=", "PREV_INSN", "(", "insn", ")", ";", "prev_i", "!=", "NULL", "&&", "(", "!", "INSN_P", "(", "prev_i", ")", "||", "GET_CODE", "(", "PATTERN", "(", "prev_i", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "prev_i", ")", ")", "==", "CLOBBER", ")", ";", "prev_i", "=", "PREV_INSN", "(", "prev_i", ")", ")", "{", "if", "(", "BARRIER_P", "(", "prev_i", ")", ")", "return", ";", "}", "if", "(", "prev_i", "==", "NULL", "||", "!", "INSN_P", "(", "prev_i", ")", ")", "return", ";", "prev_attr", "=", "mt_get_attr_type", "(", "prev_i", ")", ";", "if", "(", "prev_attr", "==", "TYPE_BRANCH", ")", "return", ";", "switch", "(", "mt_get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_STORE", ":", "if", "(", "(", "prev_attr", "==", "TYPE_LOAD", "||", "prev_attr", "==", "TYPE_STORE", ")", "&&", "TARGET_MS1_64_001", ")", "{", "mt_nops_required", "=", "1", ";", "mt_nop_reasons", "=", "\"consecutive mem ops\"", ";", "}", "case", "TYPE_ARITH", ":", "case", "TYPE_COMPLEX", ":", "if", "(", "prev_attr", "==", "TYPE_LOAD", "&&", "insn_true_dependent_p", "(", "prev_i", ",", "insn", ")", ")", "{", "mt_nops_required", "=", "1", ";", "mt_nop_reasons", "=", "\"load->arith dependency delay\"", ";", "}", "break", ";", "case", "TYPE_BRANCH", ":", "if", "(", "insn_dependent_p", "(", "prev_i", ",", "insn", ")", ")", "{", "if", "(", "prev_attr", "==", "TYPE_ARITH", "&&", "TARGET_MS1_64_001", ")", "{", "mt_nops_required", "=", "1", ";", "mt_nop_reasons", "=", "\"arith->branch dependency delay\"", ";", "}", "else", "if", "(", "prev_attr", "==", "TYPE_LOAD", ")", "{", "if", "(", "TARGET_MS1_64_001", ")", "mt_nops_required", "=", "2", ";", "else", "mt_nops_required", "=", "1", ";", "mt_nop_reasons", "=", "\"load->branch dependency delay\"", ";", "}", "}", "break", ";", "default", ":", "fatal_insn", "(", "\"mt_final_prescan_insn, invalid insn #1\"", ",", "insn", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "The", "following", "determines", "the", "number", "of", "nops", "that", "need", "to", "be", "inserted", "between", "the", "previous", "instructions", "and", "current", "instruction", "to", "avoid", "pipeline", "hazards", "on", "the", "mt", "processor", ".", "Remember", "that", "the", "function", "is", "not", "called", "for", "asm", "insns", "." ]

[ "mt", "0", "\"\"", "1", "\"consecutive mem ops\"", "1", "\"load->arith dependency delay\"", "1", "\"arith->branch dependency delay\"", "2", "1", "\"load->branch dependency delay\"", "\"mt_final_prescan_insn, invalid insn #1\"" ]

[]

[ "<s>", "static", "void", "frv_optimize_membar_local", "(", "basic_block", "bb", ",", "struct", "frv_io", "*", "next_io", ",", "rtx_insn", "*", "*", "last_membar", ")", "{", "HARD_REG_SET", "used_regs", ";", "rtx", "next_membar", ",", "set", ";", "rtx_insn", "*", "insn", ";", "bool", "next_is_end_p", ";", "memset", "(", "next_io", ",", "0", ",", "sizeof", "(", "*", "next_io", ")", ")", ";", "next_is_end_p", "=", "true", ";", "next_membar", "=", "0", ";", "CLEAR_HARD_REG_SET", "(", "used_regs", ")", ";", "for", "(", "insn", "=", "BB_END", "(", "bb", ")", ";", "insn", "!=", "BB_HEAD", "(", "bb", ")", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "memset", "(", "next_io", ",", "0", ",", "sizeof", "(", "struct", "frv_io", ")", ")", ";", "next_is_end_p", "=", "false", ";", "CLEAR_HARD_REG_SET", "(", "used_regs", ")", ";", "}", "else", "if", "(", "INSN_P", "(", "insn", ")", ")", "switch", "(", "recog_memoized", "(", "insn", ")", ")", "{", "case", "CODE_FOR_optional_membar_qi", ":", "case", "CODE_FOR_optional_membar_hi", ":", "case", "CODE_FOR_optional_membar_si", ":", "case", "CODE_FOR_optional_membar_di", ":", "next_membar", "=", "insn", ";", "if", "(", "next_is_end_p", ")", "{", "*", "last_membar", "=", "insn", ";", "frv_extract_membar", "(", "next_io", ",", "insn", ")", ";", "next_is_end_p", "=", "false", ";", "}", "else", "{", "struct", "frv_io", "prev_io", ";", "frv_extract_membar", "(", "&", "prev_io", ",", "insn", ")", ";", "if", "(", "frv_io_fixed_order_p", "(", "&", "prev_io", ",", "next_io", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; [Local] Removing membar %d since order\"", "\" of accesses is guaranteed\\n\"", ",", "INSN_UID", "(", "next_membar", ")", ")", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "delete_insn", "(", "next_membar", ")", ";", "next_membar", "=", "0", ";", "}", "*", "next_io", "=", "prev_io", ";", "}", "break", ";", "default", ":", "if", "(", "next_io", "->", "var_address", ")", "note_stores", "(", "PATTERN", "(", "insn", ")", ",", "frv_io_check_address", ",", "&", "next_io", "->", "var_address", ")", ";", "set", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "next_io", "->", "type", "==", "FRV_IO_READ", "&&", "next_io", "->", "var_address", "!=", "0", "&&", "next_membar", "!=", "0", "&&", "GET_CODE", "(", "set", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "REG", "&&", "TEST_HARD_REG_BIT", "(", "used_regs", ",", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", ")", ")", "{", "rtx", "src", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "ZERO_EXTEND", ")", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", "&&", "rtx_equal_p", "(", "XEXP", "(", "src", ",", "0", ")", ",", "next_io", "->", "var_address", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\";; [Local] Removing membar %d since the target\"", "\" of %d is used before the I/O operation\\n\"", ",", "INSN_UID", "(", "next_membar", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "next_membar", "==", "*", "last_membar", ")", "*", "last_membar", "=", "0", ";", "delete_insn", "(", "next_membar", ")", ";", "next_membar", "=", "0", ";", "}", "}", "if", "(", "volatile_refs_p", "(", "PATTERN", "(", "insn", ")", ")", ")", "CLEAR_HARD_REG_SET", "(", "used_regs", ")", ";", "else", "note_stores", "(", "PATTERN", "(", "insn", ")", ",", "frv_io_handle_set", ",", "&", "used_regs", ")", ";", "note_uses", "(", "&", "PATTERN", "(", "insn", ")", ",", "frv_io_handle_use", ",", "&", "used_regs", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Go", "through", "block", "BB", "looking", "for", "membars", "to", "remove", ".", "There", "are", "two", "cases", "where", "intra-block", "analysis", "is", "enough", ":", "-", "a", "membar", "is", "redundant", "if", "it", "occurs", "between", "two", "consecutive", "I/O", "operations", "and", "if", "those", "operations", "are", "guaranteed", "to", "complete", "in", "order", ".", "-", "a", "membar", "for", "a", "__builtin_read", "is", "redundant", "if", "the", "result", "is", "used", "before", "the", "next", "I/O", "operation", "is", "issued", ".", "If", "the", "last", "membar", "in", "the", "block", "could", "not", "be", "removed", ",", "and", "there", "are", "guaranteed", "to", "be", "no", "I/O", "operations", "between", "that", "membar", "and", "the", "end", "of", "the", "block", ",", "store", "the", "membar", "in", "*", "LAST_MEMBAR", ",", "otherwise", "store", "null", ".", "Describe", "the", "block", "'s", "first", "I/O", "operation", "in", "*", "NEXT_IO", ".", "Describe", "an", "unknown", "operation", "if", "the", "block", "does", "n't", "do", "any", "I/O", "." ]

[ "frv", "0", "0", "0", "\";; [Local] Removing membar %d since order\"", "\" of accesses is guaranteed\\n\"", "0", "0", "0", "0", "0", "\";; [Local] Removing membar %d since the target\"", "\" of %d is used before the I/O operation\\n\"", "0", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "pa_starting_frame_offset", "(", "void", ")", "{", "return", "8", ";", "}", "</s>" ]

[ "Implement", "TARGET_STARTING_FRAME_OFFSET", ".", "On", "the", "32-bit", "ports", ",", "we", "reserve", "one", "slot", "for", "the", "previous", "frame", "pointer", "and", "one", "fill", "slot", ".", "The", "fill", "slot", "is", "for", "compatibility", "with", "HP", "compiled", "programs", ".", "On", "the", "64-bit", "ports", ",", "we", "reserve", "one", "slot", "for", "the", "previous", "frame", "pointer", "." ]

[ "pa", "8" ]

[]

[ "<s>", "void", "P2DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"<-------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "N", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", ";", "auto", "DL", "=", "CurDAG", "->", "getDataLayout", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"frame index node is being selected\\n\"", ")", ";", "FrameIndexSDNode", "*", "FIN", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FIN", "->", "getIndex", "(", ")", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "DL", ")", ")", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "P2", "::", "FRMIDX", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "DL", ")", ",", "TFI", ")", ";", "return", ";", "}", "case", "ISD", "::", "SMUL_LOHI", ":", "case", "ISD", "::", "UMUL_LOHI", ":", "{", "selectMultiplication", "(", "N", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Done selecting, chose \"", ";", "N", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

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

[ "P2", "P2", "\"<-------->\\n\"", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::FrameIndex", "\"frame index node is being selected\\n\"", "P2::FRMIDX", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "\"Done selecting, chose \"" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "hasLoadFromStackSlot", "(", "MI", ",", "Accesses", ")", "&&", "Accesses", ".", "size", "(", ")", "==", "1", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "ARM", "ARM", "1", "1" ]

[]

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

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "RV16K" ]

[]

[ "<s>", "rtx", "pa_maybe_emit_compare_and_swap_exchange_loop", "(", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "if", "(", "can_compare_and_swap_p", "(", "mode", ",", "true", ")", ")", "{", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "mode", ")", ")", "target", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "pa_expand_compare_and_swap_loop", "(", "mem", ",", "target", ",", "val", ",", "NULL_RTX", ")", ")", "return", "target", ";", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "This", "function", "tries", "to", "implement", "an", "atomic", "exchange", "operation", "using", "a", "compare_and_swap", "loop", ".", "VAL", "is", "written", "to", "*", "MEM", ".", "The", "previous", "contents", "of", "*", "MEM", "are", "returned", ",", "using", "TARGET", "if", "possible", ".", "No", "memory", "model", "is", "required", "since", "a", "compare_and_swap", "loop", "is", "seq-cst", "." ]

[ "pa" ]

[]

[ "<s>", "static", "void", "arc_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.cpu %s\\n\"", ",", "arc_cpu_string", ")", ";", "}", "</s>" ]

[ "Set", "the", "cpu", "type", "and", "print", "out", "other", "fancy", "things", ",", "at", "the", "top", "of", "the", "file", "." ]

[ "arc", "\"\\t.cpu %s\\n\"" ]

[]

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

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

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

[]

[ "<s>", "BitVector", "AVRRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R1R0", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SPL", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SPH", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R28", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R29R28", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::R0", "AVR::R1", "AVR::R1R0", "AVR::SPL", "AVR::SPH", "AVR::SP", "AVR::R28", "AVR::R29", "AVR::R29R28" ]

[]

[ "<s>", "static", "void", "union_defs", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx", "insn", ",", "df_ref", "use", ")", "{", "struct", "df_link", "*", "link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "link", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_in", "=", "1", ";", "while", "(", "link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "link", "->", "ref", ")", ")", "insn_entry", "[", "INSN_UID", "(", "insn", ")", "]", ".", "is_live_in", "=", "1", ";", "if", "(", "DF_REF_INSN_INFO", "(", "link", "->", "ref", ")", ")", "{", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "(", "void", ")", "unionfind_union", "(", "insn_entry", "+", "INSN_UID", "(", "insn", ")", ",", "insn_entry", "+", "INSN_UID", "(", "def_insn", ")", ")", ";", "}", "link", "=", "link", "->", "next", ";", "}", "}", "</s>" ]

[ "Union", "INSN", "with", "all", "insns", "containing", "definitions", "that", "reach", "USE", ".", "Detect", "whether", "USE", "is", "live-in", "to", "the", "current", "function", "." ]

[ "powerpcspe", "1", "1" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "cum", "->", "nregs", "=", "18", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "if", "(", "!", "libname", "&&", "fntype", ")", "{", "int", "stdarg", "=", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "0", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", ";", "if", "(", "stdarg", ")", "cum", "->", "nregs", "=", "0", ";", "}", "}", "</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", "." ]

[ "avr", "18", "0", "0" ]

[]

[ "<s>", "bool", "DetectRoundChange", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "for", "(", "auto", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MBBI", ";", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "SP", "::", "CALL", "&&", "MI", ".", "getNumOperands", "(", ")", ">", "0", ")", "{", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StringRef", "FuncName", "=", "MO", ".", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "if", "(", "FuncName", ".", "compare_insensitive", "(", "\"fesetround\"", ")", "==", "0", ")", "{", "errs", "(", ")", "<<", "\"Error: You are using the detectroundchange \"", "\"option to detect rounding changes that will \"", "\"cause LEON errata. The only way to fix this \"", "\"is to remove the call to fesetround from \"", "\"the source code.\\n\"", ";", "}", "}", "}", "}", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::CALL", "0", "0", "\"fesetround\"", "0", "\"Error: You are using the detectroundchange \"", "\"option to detect rounding changes that will \"", "\"cause LEON errata. The only way to fix this \"", "\"is to remove the call to fesetround from \"", "\"the source code.\\n\"" ]

[]

[ "<s>", "static", "bool", "rs6000_member_type_forces_blk", "(", "const_tree", "field", ",", "machine_mode", "mode", ")", "{", "return", "(", "(", "TARGET_SPE", "&&", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "VECTOR_TYPE", ")", "||", "(", "TARGET_E500_DOUBLE", "&&", "mode", "==", "DFmode", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "structure", ",", "union", "or", "array", "containing", "FIELD", "should", "be", "accessed", "using", "`", "BLKMODE", "'", ".", "For", "the", "SPE", ",", "simd", "types", "are", "V2SI", ",", "and", "gcc", "can", "be", "tempted", "to", "put", "the", "entire", "thing", "in", "a", "DI", "and", "use", "subregs", "to", "access", "the", "internals", ".", "store_bit_field", "(", ")", "will", "force", "(", "subreg", ":", "DI", "(", "reg", ":", "V2SI", "x", ")", ")", "'s", "to", "the", "back-end", ".", "Because", "a", "single", "GPR", "can", "hold", "a", "V2SI", ",", "but", "not", "a", "DI", ",", "the", "best", "thing", "to", "do", "is", "set", "structs", "to", "BLKmode", "and", "avoid", "Severe", "Tire", "Damage", ".", "On", "e500", "v2", ",", "DF", "and", "DI", "modes", "suffer", "from", "the", "same", "anomaly", ".", "DF", "can", "fit", "into", "1", ",", "whereas", "DI", "still", "needs", "two", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "static", "int", "const_int_cost", "(", "rtx", "constant", ")", "{", "switch", "(", "const_method", "(", "constant", ")", ")", "{", "case", "MOVQ", ":", "return", "0", ";", "case", "MVZ", ":", "case", "MVS", ":", "case", "NOTB", ":", "case", "NOTW", ":", "case", "NEGW", ":", "case", "SWAP", ":", "return", "1", ";", "case", "MOVL", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "constant", "I", "into", "a", "data", "register", "." ]

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

[]

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

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

[ "Nyuzi" ]

[]

[ "<s>", "static", "reg_class_t", "sparc_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "{", "if", "(", "FP_REG_CLASS_P", "(", "rclass", ")", "||", "rclass", "==", "GENERAL_OR_FP_REGS", "||", "rclass", "==", "GENERAL_OR_EXTRA_FP_REGS", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "!", "TARGET_FPU", ")", "||", "(", "mode", "==", "TFmode", "&&", "!", "const_zero_operand", "(", "x", ",", "mode", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", ")", "return", "GENERAL_REGS", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "if", "(", "!", "FP_REG_CLASS_P", "(", "rclass", ")", "||", "!", "(", "const_zero_operand", "(", "x", ",", "mode", ")", "||", "const_all_ones_operand", "(", "x", ",", "mode", ")", ")", ")", "return", "NO_REGS", ";", "}", "}", "if", "(", "TARGET_VIS3", "&&", "!", "TARGET_ARCH64", "&&", "(", "rclass", "==", "EXTRA_FP_REGS", "||", "rclass", "==", "GENERAL_OR_EXTRA_FP_REGS", ")", ")", "{", "int", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "SPARC_INT_REG_P", "(", "regno", ")", ")", "return", "(", "rclass", "==", "EXTRA_FP_REGS", "?", "FP_REGS", ":", "GENERAL_OR_FP_REGS", ")", ";", "}", "return", "rclass", ";", "}", "</s>" ]

[ "Implement", "TARGET_PREFERRED_RELOAD_CLASS", ":", "-", "We", "ca", "n't", "load", "constants", "into", "FP", "registers", ".", "-", "We", "ca", "n't", "load", "FP", "constants", "into", "integer", "registers", "when", "soft-float", ",", "because", "there", "is", "no", "soft-float", "pattern", "with", "a", "r/F", "constraint", ".", "-", "We", "ca", "n't", "load", "FP", "constants", "into", "integer", "registers", "for", "TFmode", "unless", "it", "is", "0.0L", ",", "because", "there", "is", "no", "movtf", "pattern", "with", "a", "r/F", "constraint", ".", "-", "Try", "and", "reload", "integer", "constants", "(", "symbolic", "or", "otherwise", ")", "back", "into", "registers", "directly", ",", "rather", "than", "having", "them", "dumped", "to", "memory", "." ]

[ "sparc" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "Cpu0" ]

[]

[ "<s>", "bool", "TPCSubregInitElimination", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Func", ")", "{", "if", "(", "!", "EnableTPCSubregInitElimination", ")", "return", "false", ";", "MF", "=", "&", "Func", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "TII", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SubregInstrs", ".", "clear", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "Func", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "unsigned", "SubregCount", "=", "TPCII", "::", "getLanesCount", "(", "I", ".", "getDesc", "(", ")", ")", ")", "{", "if", "(", "removeInitialization", "(", "&", "I", ",", "SubregCount", ")", ")", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "int", "arm_no_early_alu_shift_dep", "(", "rtx", "producer", ",", "rtx", "consumer", ")", "{", "rtx", "value", ",", "op", ";", "rtx", "early_op", ";", "if", "(", "!", "arm_get_set_operands", "(", "producer", ",", "consumer", ",", "&", "value", ",", "&", "op", ")", ")", "return", "0", ";", "if", "(", "(", "early_op", "=", "arm_find_shift_sub_rtx", "(", "op", ")", ")", ")", "return", "!", "reg_overlap_mentioned_p", "(", "value", ",", "early_op", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "the", "CONSUMER", "instruction", "(", "an", "ALU", "op", ")", "does", "not", "have", "an", "early", "register", "shift", "value", "or", "amount", "dependency", "on", "the", "result", "of", "PRODUCER", "." ]

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

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createCookieSetterPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128RegClass", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "}", "addPass", "(", "createX86FixupVCalls", "(", ")", ")", ";", "addPass", "(", "createMOVToLEAPass", "(", ")", ")", ";", "addPass", "(", "createEquivSubstPass", "(", ")", ")", ";", "if", "(", "TM", "->", "Options", ".", "NOPInsertion", ")", "{", "addPass", "(", "createNOPInsertionPass", "(", "Is64Bit", ")", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "AlphaAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "Alpha", "Alpha" ]

[]

[ "<s>", "static", "void", "nvptx_record_offload_symbol", "(", "tree", "decl", ")", "{", "switch", "(", "TREE_CODE", "(", "decl", ")", ")", "{", "case", "VAR_DECL", ":", "fprintf", "(", "asm_out_file", ",", "\"//:VAR_MAP \\\"%s\\\"\\n\"", ",", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", ";", "break", ";", "case", "FUNCTION_DECL", ":", "{", "tree", "attr", "=", "oacc_get_fn_attrib", "(", "decl", ")", ";", "tree", "dims", "=", "attr", "?", "TREE_VALUE", "(", "attr", ")", ":", "NULL_TREE", ";", "fprintf", "(", "asm_out_file", ",", "\"//:FUNC_MAP \\\"%s\\\"\"", ",", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ")", ";", "for", "(", ";", "dims", ";", "dims", "=", "TREE_CHAIN", "(", "dims", ")", ")", "{", "int", "size", "=", "TREE_INT_CST_LOW", "(", "TREE_VALUE", "(", "dims", ")", ")", ";", "gcc_assert", "(", "!", "TREE_PURPOSE", "(", "dims", ")", ")", ";", "fprintf", "(", "asm_out_file", ",", "\", %#x\"", ",", "size", ")", ";", "}", "fprintf", "(", "asm_out_file", ",", "\"\\n\"", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Record", "a", "symbol", "for", "mkoffload", "to", "enter", "into", "the", "mapping", "table", "." ]

[ "nvptx", "\"//:VAR_MAP \\\"%s\\\"\\n\"", "\"//:FUNC_MAP \\\"%s\\\"\"", "\", %#x\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "HexagonDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "case", "'o'", ":", "case", "'v'", ":", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectAddr", "(", "Op", ".", "getNode", "(", ")", ",", "Op", ",", "Op0", ",", "Op1", ")", ")", "return", "true", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "char", "*", "detect_caches_linux", "(", "void", ")", "{", "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "const", "char", "*", "platform", ";", "platform", "=", "elf_platform", "(", ")", ";", "if", "(", "platform", "!=", "NULL", ")", "{", "l1_line", "=", "128", ";", "if", "(", "platform", "[", "5", "]", "==", "'6'", ")", "l1_sizekb", "=", "64", ";", "else", "l1_sizekb", "=", "32", ";", "}", "else", "{", "l1_line", "=", "elf_dcachebsize", "(", ")", ";", "l1_sizekb", "=", "32", ";", "}", "l1_assoc", "=", "0", ";", "l2_sizekb", "=", "512", ";", "return", "describe_cache", "(", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ")", ";", "}", "</s>" ]

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

[ "powerpcspe", "128", "5", "64", "32", "32", "0", "512" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "MCSymbolWasm", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "true", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__cpp_exception\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_EVENT", ")", ";", "WasmSym", "->", "setEventType", "(", "{", "wasm", "::", "WASM_EVENT_ATTRIBUTE_EXCEPTION", ",", "0", "}", ")", ";", "WasmSym", "->", "setWeak", "(", "true", ")", ";", "WasmSym", "->", "setExternal", "(", "true", ")", ";", "Params", ".", "push_back", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "ValType", "::", "I64", ":", "wasm", "::", "ValType", "::", "I32", ")", ";", "}", "else", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "GetLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "}", "auto", "Signature", "=", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "\"__cpp_exception\"", "0", "wasm::WASM_SYMBOL_TYPE_EVENT", "wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION", "0", "wasm::ValType", "wasm::ValType", "wasm::WASM_SYMBOL_TYPE_FUNCTION", "wasm::WasmSignature" ]

[]

[ "<s>", "const", "char", "*", "TeakTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "NULL", ";", "case", "TeakISD", "::", "RET_FLAG", ":", "return", "\"RetFlag\"", ";", "case", "TeakISD", "::", "LOAD_SYM", ":", "return", "\"LOAD_SYM\"", ";", "case", "TeakISD", "::", "MOVEi32", ":", "return", "\"MOVEi32\"", ";", "case", "TeakISD", "::", "CALL", ":", "return", "\"CALL\"", ";", "}", "}", "</s>" ]

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

[ "Teak", "Teak", "TeakISD::RET_FLAG", "\"RetFlag\"", "TeakISD::LOAD_SYM", "\"LOAD_SYM\"", "TeakISD::MOVEi32", "\"MOVEi32\"", "TeakISD::CALL", "\"CALL\"" ]

[]

[ "<s>", "const", "char", "*", "output_move_single", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "if", "(", "REG_P", "(", "dst", ")", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "\"mov %1,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", ")", "{", "HOST_WIDE_INT", "value", "=", "INTVAL", "(", "src", ")", ";", "if", "(", "CONST_OK_FOR_J", "(", "value", ")", ")", "return", "\"mov %1,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_K", "(", "value", ")", ")", "return", "\"movea %1,%.,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_L", "(", "value", ")", ")", "return", "\"movhi hi0(%1),%.,%0\"", ";", "else", "if", "(", "TARGET_V850E_UP", ")", "return", "\"mov %1,%0\"", ";", "else", "return", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "src", ")", "==", "SFmode", ")", "{", "HOST_WIDE_INT", "high", ",", "low", ";", "const_double_split", "(", "src", ",", "&", "high", ",", "&", "low", ")", ";", "if", "(", "CONST_OK_FOR_J", "(", "high", ")", ")", "return", "\"mov %F1,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_K", "(", "high", ")", ")", "return", "\"movea %F1,%.,%0\"", ";", "else", "if", "(", "CONST_OK_FOR_L", "(", "high", ")", ")", "return", "\"movhi hi0(%F1),%.,%0\"", ";", "else", "if", "(", "TARGET_V850E_UP", ")", "return", "\"mov %F1,%0\"", ";", "else", "return", "\"movhi hi(%F1),%.,%0\\n\\tmovea lo(%F1),%0,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", ")", "return", "\"%S1ld%W1 %1,%0\"", ";", "else", "if", "(", "special_symbolref_operand", "(", "src", ",", "VOIDmode", ")", ")", "return", "\"movea %O1(%P1),%Q1,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "src", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "src", ")", "==", "CONST", ")", "{", "if", "(", "TARGET_V850E_UP", ")", "return", "\"mov hilo(%1),%0\"", ";", "else", "return", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "HIGH", ")", "return", "\"movhi hi(%1),%.,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "LO_SUM", ")", "{", "operands", "[", "2", "]", "=", "XEXP", "(", "src", ",", "0", ")", ";", "operands", "[", "3", "]", "=", "XEXP", "(", "src", ",", "1", ")", ";", "return", "\"movea lo(%3),%2,%0\"", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "dst", ")", "==", "MEM", ")", "{", "if", "(", "REG_P", "(", "src", ")", ")", "return", "\"%S0st%W0 %1,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "src", ")", "==", "0", ")", "return", "\"%S0st%W0 %.,%0\"", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST_DOUBLE", "&&", "CONST0_RTX", "(", "GET_MODE", "(", "dst", ")", ")", "==", "src", ")", "return", "\"%S0st%W0 %.,%0\"", ";", "}", "fatal_insn", "(", "\"output_move_single:\"", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "src", ")", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "appropriate", "code", "to", "load", "up", "a", "1", ",", "2", ",", "or", "4", "integer/floating", "point", "value", "." ]

[ "v850", "0", "1", "\"mov %1,%0\"", "\"mov %1,%0\"", "\"movea %1,%.,%0\"", "\"movhi hi0(%1),%.,%0\"", "\"mov %1,%0\"", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", "\"mov %F1,%0\"", "\"movea %F1,%.,%0\"", "\"movhi hi0(%F1),%.,%0\"", "\"mov %F1,%0\"", "\"movhi hi(%F1),%.,%0\\n\\tmovea lo(%F1),%0,%0\"", "\"%S1ld%W1 %1,%0\"", "\"movea %O1(%P1),%Q1,%0\"", "\"mov hilo(%1),%0\"", "\"movhi hi(%1),%.,%0\\n\\tmovea lo(%1),%0,%0\"", "\"movhi hi(%1),%.,%0\"", "2", "0", "3", "1", "\"movea lo(%3),%2,%0\"", "\"%S0st%W0 %1,%0\"", "0", "\"%S0st%W0 %.,%0\"", "\"%S0st%W0 %.,%0\"", "\"output_move_single:\"", "\"\"" ]

[]

[ "<s>", "static", "void", "alpha_output_mi_thunk_osf", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", "ATTRIBUTE_UNUSED", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", ",", "tree", "function", ")", "{", "const", "char", "*", "fnname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "thunk_fndecl", ")", ")", ";", "HOST_WIDE_INT", "hi", ",", "lo", ";", "rtx", "this_rtx", ",", "funexp", ";", "rtx_insn", "*", "insn", ";", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "emit_note", "(", "NOTE_INSN_PROLOGUE_END", ")", ";", "if", "(", "aggregate_value_p", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "function", ")", ")", ",", "function", ")", ")", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "17", ")", ";", "else", "this_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "16", ")", ";", "lo", "=", "(", "(", "delta", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "delta", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "delta", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "if", "(", "lo", ")", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ",", "delta", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "vcall_offset", ")", "{", "rtx", "tmp", ",", "tmp2", ";", "tmp", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "this_rtx", ")", ")", ";", "lo", "=", "(", "(", "vcall_offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "hi", "=", "(", "(", "(", "vcall_offset", "-", "lo", ")", "&", "0xffffffff", ")", "^", "0x80000000", ")", "-", "0x80000000", ";", "if", "(", "hi", "+", "lo", "==", "vcall_offset", ")", "{", "if", "(", "hi", ")", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "}", "else", "{", "tmp2", "=", "alpha_emit_set_long_const", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "vcall_offset", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "tmp", ",", "tmp", ",", "tmp2", ")", ")", ";", "lo", "=", "0", ";", "}", "if", "(", "lo", ")", "tmp2", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "GEN_INT", "(", "lo", ")", ")", ";", "else", "tmp2", "=", "tmp", ";", "emit_move_insn", "(", "tmp", ",", "gen_rtx_MEM", "(", "Pmode", ",", "tmp2", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "this_rtx", ",", "this_rtx", ",", "tmp", ")", ")", ";", "}", "if", "(", "!", "TREE_USED", "(", "function", ")", ")", "{", "assemble_external", "(", "function", ")", ";", "TREE_USED", "(", "function", ")", "=", "1", ";", "}", "funexp", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "0", ")", ";", "funexp", "=", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "funexp", ")", ";", "insn", "=", "emit_call_insn", "(", "gen_sibcall", "(", "funexp", ",", "const0_rtx", ")", ")", ";", "SIBLING_CALL_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "get_insns", "(", ")", ";", "shorten_branches", "(", "insn", ")", ";", "assemble_start_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "final_start_function", "(", "insn", ",", "file", ",", "1", ")", ";", "final", "(", "insn", ",", "file", ",", "1", ")", ";", "final_end_function", "(", ")", ";", "assemble_end_function", "(", "thunk_fndecl", ",", "fnname", ")", ";", "}", "</s>" ]

[ "Emit", "a", "tail", "call", "to", "FUNCTION", "after", "adjusting", "THIS", "by", "DELTA", ".", "In", "order", "to", "avoid", "the", "hordes", "of", "differences", "between", "generated", "code", "with", "and", "without", "TARGET_EXPLICIT_RELOCS", ",", "and", "to", "avoid", "duplicating", "lots", "of", "code", "loading", "up", "large", "constants", ",", "generate", "rtl", "and", "emit", "it", "instead", "of", "going", "straight", "to", "text", ".", "Not", "sure", "why", "this", "idea", "has", "n't", "been", "explored", "before", "..." ]

[ "alpha", "17", "16", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "0", "0", "0xffff", "0x8000", "0x8000", "0xffffffff", "0x80000000", "0x80000000", "1", "0", "1", "0", "1", "1", "1" ]

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "MCRegisterInfo", "&", ",", "const", "Triple", "&", "TT", ",", "const", "MCTargetOptions", "&", "Options", ")", "{", "return", "new", "WebAssemblyMCAsmInfo", "(", "TT", ",", "Options", ")", ";", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "arc_initialize_trampoline", "(", "rtx", "tramp", "ATTRIBUTE_UNUSED", ",", "rtx", "fnaddr", "ATTRIBUTE_UNUSED", ",", "rtx", "cxt", "ATTRIBUTE_UNUSED", ")", "{", "}", "</s>" ]

[ "With", "potentially", "multiple", "shared", "objects", "loaded", ",", "and", "multiple", "stacks", "present", "for", "multiple", "thereds", "where", "trampolines", "might", "reside", ",", "a", "simple", "range", "check", "will", "likely", "not", "suffice", "for", "the", "profiler", "to", "tell", "if", "a", "callee", "is", "a", "trampoline", ".", "We", "a", "speedier", "check", "by", "making", "the", "trampoline", "start", "at", "an", "address", "that", "is", "not", "4-byte", "aligned", ".", "A", "trampoline", "looks", "like", "this", ":", "nop_s", "0x78e0entry", ":", "ld_s", "r12", ",", "[", "pcl,12", "]", "0xd403", "ld", "r11", ",", "[", "pcl,12", "]", "0x170c", "700b", "j_s", "[", "r12", "]", "0x7c00", "nop_s", "0x78e0", "The", "fastest", "trampoline", "to", "execute", "for", "trampolines", "within", "+-8KB", "of", "CTX", "would", "be", ":", "add2", "r11", ",", "pcl", ",", "s12", "j", "[", "limm", "]", "0x20200f80", "limm", "and", "that", "would", "also", "be", "faster", "to", "write", "to", "the", "stack", "by", "computing", "the", "offset", "from", "CTX", "to", "TRAMP", "at", "compile", "time", ".", "However", ",", "it", "would", "really", "be", "better", "to", "get", "rid", "of", "the", "high", "cost", "of", "cache", "invalidation", "when", "generating", "trampolines", ",", "which", "requires", "that", "the", "code", "part", "of", "trampolines", "stays", "constant", ",", "and", "additionally", "either", "-", "making", "sure", "that", "no", "executable", "code", "but", "trampolines", "is", "on", "the", "stack", ",", "no", "icache", "entries", "linger", "for", "the", "area", "of", "the", "stack", "from", "when", "before", "the", "stack", "was", "allocated", ",", "and", "allocating", "trampolines", "in", "trampoline-only", "cache", "lines", "or", "-", "allocate", "trampolines", "fram", "a", "special", "pool", "of", "pre-allocated", "trampolines", "." ]

[ "arc" ]

[]

[ "<s>", "pa_asm_output_aligned_local", "(", "FILE", ",", "NAME", ",", "SIZE", ",", "ALIGN", ")", "{", "rtx", "addr", "=", "ADDR", ";", "\\", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "\\", "{", "\\", "case", "REG", ":", "\\", "fprintf", "(", "FILE", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ")", "]", ")", ";", "\\", "break", ";", "\\", "case", "PLUS", ":", "\\", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "\\", "fprintf", "(", "FILE", ",", "\"%d(%s)\"", ",", "(", "int", ")", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ",", "\\", "reg_names", "[", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "]", ")", ";", "\\", "break", ";", "\\", "case", "LO_SUM", ":", "\\", "if", "(", "!", "symbolic_operand", "(", "XEXP", "(", "addr", ",", "1", ")", ",", "VOIDmode", ")", ")", "\\", "fputs", "(", "\"R'\"", ",", "FILE", ")", ";", "\\", "else", "if", "(", "flag_pic", "==", "0", ")", "\\", "fputs", "(", "\"RR'\"", ",", "FILE", ")", ";", "\\", "else", "\\", "fputs", "(", "\"RT'\"", ",", "FILE", ")", ";", "\\", "pa_output_global_address", "(", "FILE", ",", "XEXP", "(", "addr", ",", "1", ")", ",", "0", ")", ";", "\\", "fputs", "(", "\"(\"", ",", "FILE", ")", ";", "\\", "output_operand", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ";", "\\", "fputs", "(", "\")\"", ",", "FILE", ")", ";", "\\", "break", ";", "\\", "case", "CONST_INT", ":", "\\", "fprintf", "(", "FILE", ",", "HOST_WIDE_INT_PRINT_DEC", "\"(%%r0)\"", ",", "INTVAL", "(", "addr", ")", ")", ";", "\\", "break", ";", "\\", "default", ":", "\\", "output_addr_const", "(", "FILE", ",", "addr", ")", ";", "\\", "}", "}", "</s>" ]

[ "We", "ca", "n't", "use", ".comm", "for", "local", "common", "storage", "as", "the", "SOM", "linker", "effectively", "treats", "the", "symbol", "as", "universal", "and", "uses", "the", "same", "storage", "for", "local", "symbols", "with", "the", "same", "name", "in", "different", "object", "files", ".", "The", ".block", "directive", "reserves", "an", "uninitialized", "block", "of", "storage", ".", "However", ",", "it", "'s", "not", "common", "storage", ".", "Fortunately", ",", "GCC", "never", "requests", "common", "storage", "with", "the", "same", "name", "in", "any", "given", "translation", "unit", "." ]

[ "pa", "\"0(%s)\"", "1", "\"%d(%s)\"", "1", "0", "1", "\"R'\"", "0", "\"RR'\"", "\"RT'\"", "1", "0", "\"(\"", "0", "0", "\")\"", "\"(%%r0)\"" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCBoolRetToIntPass", "(", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createPPCLowerMASSVEntriesPass", "(", ")", ")", ";", "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", "PPC", "0" ]

[]

[ "<s>", "static", "void", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "MBlazeFI", "->", "adjustLoadArgsFI", "(", "MFI", ")", ";", "MBlazeFI", "->", "adjustStoreVarArgsFI", "(", "MFI", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Original Frame Size: \"", "<<", "FrameSize", "<<", "\"\\n\"", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Aligned Frame Size: \"", "<<", "FrameSize", "<<", "\"\\n\"", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "\"Original Frame Size: \"", "\"\\n\"", "1", "\"Aligned Frame Size: \"", "\"\\n\"" ]

[]

[ "<s>", "void", "xstormy16_output_addr_vec", "(", "FILE", "*", "file", ",", "rtx", "label", "ATTRIBUTE_UNUSED", ",", "rtx", "table", ")", "{", "int", "vlen", ",", "idx", ";", "switch_to_section", "(", "current_function_section", "(", ")", ")", ";", "vlen", "=", "XVECLEN", "(", "table", ",", "0", ")", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "fputs", "(", "\"\\tjmpf \"", ",", "file", ")", ";", "output_asm_label", "(", "XEXP", "(", "XVECEXP", "(", "table", ",", "0", ",", "idx", ")", ",", "0", ")", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "</s>" ]

[ "Output", "an", "ADDR_VEC", ".", "It", "is", "output", "as", "a", "sequence", "of", "'jmpf", "'", "instructions", ",", "without", "label", "or", "alignment", "or", "any", "other", "special", "constructs", ".", "We", "know", "that", "the", "previous", "instruction", "will", "be", "the", "`", "tablejump_pcrel", "'", "output", "above", ".", "TODO", ":", "it", "might", "be", "nice", "to", "output", "'br", "'", "instructions", "if", "they", "could", "all", "reach", "." ]

[ "stormy16", "0", "0", "\"\\tjmpf \"", "0", "0" ]

[]

[ "<s>", "void", "rl78_setup_peep_movhi", "(", "rtx", "*", "operands", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "i", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "i", "+", "4", "]", "=", "gen_rtx_REG", "(", "HImode", ",", "REGNO", "(", "operands", "[", "i", "]", ")", ")", ";", "break", ";", "case", "CONST_INT", ":", "operands", "[", "i", "+", "4", "]", "=", "GEN_INT", "(", "(", "INTVAL", "(", "operands", "[", "i", "]", ")", "&", "0xff", ")", "+", "(", "(", "char", ")", "INTVAL", "(", "operands", "[", "i", "+", "2", "]", ")", ")", "*", "256", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "i", "+", "4", "]", "=", "adjust_address", "(", "operands", "[", "i", "]", ",", "HImode", ",", "0", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "</s>" ]

[ "Likewise", ",", "when", "a", "peephole", "is", "activated", ",", "this", "function", "helps", "compute", "the", "new", "operands", "." ]

[ "rl78", "0", "2", "4", "4", "0xff", "2", "256", "4", "0" ]

[]

[ "<s>", "bool", "HexagonOptimizeSZextends", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "unsigned", "Idx", "=", "1", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "F", ".", "getAttributes", "(", ")", ".", "hasAttribute", "(", "Idx", ",", "Attribute", "::", "SExt", ")", ")", "{", "if", "(", "!", "isa", "<", "PointerType", ">", "(", "Arg", ".", "getType", "(", ")", ")", ")", "{", "for", "(", "auto", "UI", "=", "Arg", ".", "use_begin", "(", ")", ";", "UI", "!=", "Arg", ".", "use_end", "(", ")", ";", ")", "{", "if", "(", "isa", "<", "SExtInst", ">", "(", "*", "UI", ")", ")", "{", "Instruction", "*", "Use", "=", "cast", "<", "Instruction", ">", "(", "*", "UI", ")", ";", "SExtInst", "*", "SI", "=", "new", "SExtInst", "(", "&", "Arg", ",", "Use", "->", "getType", "(", ")", ")", ";", "assert", "(", "EVT", "::", "getEVT", "(", "SI", "->", "getType", "(", ")", ")", "==", "(", "EVT", "::", "getEVT", "(", "Use", "->", "getType", "(", ")", ")", ")", ")", ";", "++", "UI", ";", "Use", "->", "replaceAllUsesWith", "(", "SI", ")", ";", "Instruction", "*", "First", "=", "&", "F", ".", "getEntryBlock", "(", ")", ".", "front", "(", ")", ";", "SI", "->", "insertBefore", "(", "First", ")", ";", "Use", "->", "eraseFromParent", "(", ")", ";", "}", "else", "{", "++", "UI", ";", "}", "}", "}", "}", "++", "Idx", ";", "}", "for", "(", "auto", "&", "B", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "B", ")", "{", "BinaryOperator", "*", "Ashr", "=", "dyn_cast", "<", "BinaryOperator", ">", "(", "&", "I", ")", ";", "if", "(", "!", "(", "Ashr", "&&", "Ashr", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AShr", ")", ")", "continue", ";", "Value", "*", "AshrOp1", "=", "Ashr", "->", "getOperand", "(", "1", ")", ";", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "AshrOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "Instruction", "*", "Shl", "=", "dyn_cast", "<", "Instruction", ">", "(", "Ashr", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "(", "Shl", "&&", "Shl", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", ")", "continue", ";", "Value", "*", "Intr", "=", "Shl", "->", "getOperand", "(", "0", ")", ";", "Value", "*", "ShlOp1", "=", "Shl", "->", "getOperand", "(", "1", ")", ";", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "ShlOp1", ")", ";", "if", "(", "!", "(", "C", "&&", "C", "->", "getSExtValue", "(", ")", "==", "16", ")", ")", "continue", ";", "if", "(", "IntrinsicInst", "*", "I", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "Intr", ")", ")", "{", "if", "(", "!", "intrinsicAlreadySextended", "(", "I", "->", "getIntrinsicID", "(", ")", ")", ")", "continue", ";", "for", "(", "auto", "UI", "=", "Ashr", "->", "user_begin", "(", ")", ",", "UE", "=", "Ashr", "->", "user_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "const", "Use", "&", "TheUse", "=", "UI", ".", "getUse", "(", ")", ";", "if", "(", "Instruction", "*", "J", "=", "dyn_cast", "<", "Instruction", ">", "(", "TheUse", ".", "getUser", "(", ")", ")", ")", "{", "J", "->", "replaceUsesOfWith", "(", "Ashr", ",", "I", ")", ";", "}", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "1", "1", "16", "0", "0", "1", "16" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getRecipEstimate", "(", "SDValue", "Operand", ",", "SelectionDAG", "&", "DAG", ",", "int", "Enabled", ",", "int", "&", "ExtraSteps", ")", "const", "{", "if", "(", "Enabled", "==", "ReciprocalEstimate", "::", "Enabled", ")", "if", "(", "SDValue", "Estimate", "=", "getEstimate", "(", "Subtarget", ",", "AArch64ISD", "::", "FRECPE", ",", "Operand", ",", "DAG", ",", "ExtraSteps", ")", ")", "{", "SDLoc", "DL", "(", "Operand", ")", ";", "EVT", "VT", "=", "Operand", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", ";", "Flags", ".", "setUnsafeAlgebra", "(", "true", ")", ";", "for", "(", "int", "i", "=", "ExtraSteps", ";", "i", ">", "0", ";", "--", "i", ")", "{", "SDValue", "Step", "=", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "FRECPS", ",", "DL", ",", "VT", ",", "Operand", ",", "Estimate", ",", "Flags", ")", ";", "Estimate", "=", "DAG", ".", "getNode", "(", "ISD", "::", "FMUL", ",", "DL", ",", "VT", ",", "Estimate", ",", "Step", ",", "Flags", ")", ";", "}", "ExtraSteps", "=", "0", ";", "return", "Estimate", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "Return", "a", "reciprocal", "estimate", "value", "for", "the", "input", "operand", "." ]

[ "AArch64", "AArch64", "AArch64ISD::FRECPE", "0", "AArch64ISD::FRECPS", "ISD::FMUL", "0" ]

[]

[ "<s>", "bool", "ARMTTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "Ty", ",", "MaybeAlign", "Alignment", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", "||", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "Ty", ")", ")", "return", "false", ";", "unsigned", "EltWidth", "=", "Ty", "->", "getScalarSizeInBits", "(", ")", ";", "return", "(", "(", "EltWidth", "==", "32", "&&", "(", "!", "Alignment", "||", "*", "Alignment", ">=", "4", ")", ")", "||", "(", "EltWidth", "==", "16", "&&", "(", "!", "Alignment", "||", "*", "Alignment", ">=", "2", ")", ")", "||", "EltWidth", "==", "8", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

[ "ARM", "ARM", "32", "4", "16", "2", "8" ]

[]

[ "<s>", "OperandMatchResultTy", "LoongArchAsmParser", "::", "tryParseRegister", "(", "unsigned", "&", "RegNo", ",", "SMLoc", "&", "StartLoc", ",", "SMLoc", "&", "EndLoc", ")", "{", "llvm_unreachable", "(", "\"Unimplemented function.\"", ")", ";", "}", "</s>" ]

[ "tryParseRegister", "-", "parse", "one", "register", "if", "possible" ]

[ "LoongArch", "LoongArch", "\"Unimplemented function.\"" ]

[]

[ "<s>", "void", "tilepro_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "tilepro_init_machine_status", ";", "if", "(", "cfun", "&&", "cfun", "->", "machine", "&&", "flag_pic", ")", "{", "static", "int", "label_num", "=", "0", ";", "char", "text_label_name", "[", "32", "]", ";", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "text_label_name", ",", "\"L_PICLNK\"", ",", "label_num", "++", ")", ";", "machine", "->", "text_label_symbol", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "ggc_strdup", "(", "text_label_name", ")", ")", ";", "machine", "->", "text_label_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "TILEPRO_PIC_TEXT_LABEL_REGNUM", ")", ";", "machine", "->", "got_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "machine", "->", "calls_tls_get_addr", "=", "false", ";", "}", "}", "</s>" ]

[ "Do", "anything", "needed", "before", "RTL", "is", "emitted", "for", "each", "function", "." ]

[ "tilepro", "0", "32", "\"L_PICLNK\"" ]

[]

[ "<s>", "tree", "function_resolver", "::", "resolve_uniform_opt_n", "(", "unsigned", "int", "nops", ")", "{", "unsigned", "int", "i", ",", "nargs", ";", "type_suffix_index", "type", ";", "if", "(", "!", "check_gp_argument", "(", "nops", ",", "i", ",", "nargs", ")", "||", "(", "type", "=", "infer_vector_type", "(", "i", ")", ")", "==", "NUM_TYPE_SUFFIXES", ")", "return", "error_mark_node", ";", "unsigned", "int", "first_arg", "=", "i", "++", ";", "for", "(", ";", "i", "<", "nargs", "-", "1", ";", "++", "i", ")", "if", "(", "!", "require_matching_vector_type", "(", "i", ",", "type", ")", ")", "return", "error_mark_node", ";", "return", "finish_opt_n_resolution", "(", "i", ",", "first_arg", ",", "type", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "(", "possibly", "predicated", ")", "function", "that", "offers", "a", "choice", "between", "taking", ":", "-", "NOPS", "like-typed", "vector", "arguments", "or", "-", "NOPS", "-", "1", "like-typed", "vector", "arguments", "followed", "by", "a", "scalar", "argument", "Return", "the", "function", "decl", "of", "the", "resolved", "function", "on", "success", ",", "otherwise", "report", "a", "suitable", "error", "and", "return", "error_mark_node", "." ]

[ "aarch64", "1" ]

[]

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

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

[ "mproc", "mproc" ]

[]

[ "<s>", "static", "void", "unicosmk_output_deferred_case_vectors", "(", "FILE", "*", "file", ")", "{", "struct", "machine_function", "*", "machine", "=", "cfun", "->", "machine", ";", "rtx", "t", ";", "if", "(", "machine", "->", "addr_list", "==", "NULL_RTX", ")", "return", ";", "data_section", "(", ")", ";", "for", "(", "t", "=", "machine", "->", "addr_list", ";", "t", ";", "t", "=", "XEXP", "(", "t", ",", "1", ")", ")", "unicosmk_output_addr_vec", "(", "file", ",", "XEXP", "(", "t", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Output", "current", "function", "'s", "deferred", "case", "vectors", "." ]

[ "alpha", "1", "0" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", "fun", ")", "{", "return", "pcrel_opt_pass", "(", "fun", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

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

[ "MCS51" ]

[]

[ "<s>", "static", "bool", "riscv_int_order_operand_ok_p", "(", "enum", "rtx_code", "code", ",", "rtx", "cmp1", ")", "{", "switch", "(", "code", ")", "{", "case", "GT", ":", "case", "GTU", ":", "return", "reg_or_0_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "GE", ":", "case", "GEU", ":", "return", "cmp1", "==", "const1_rtx", ";", "case", "LT", ":", "case", "LTU", ":", "return", "arith_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "LE", ":", "return", "sle_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "case", "LEU", ":", "return", "sleu_operand", "(", "cmp1", ",", "VOIDmode", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "CMP1", "is", "a", "suitable", "second", "operand", "for", "integer", "ordering", "test", "CODE", ".", "See", "also", "the", "*", "sCC", "patterns", "in", "riscv.md", "." ]

[ "riscv" ]

[]

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

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

[ "FISC" ]

[]

[ "<s>", "void", "MipsTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SystemZELFFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "ZFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "BackChain", "=", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"backchain\"", ")", ";", "if", "(", "!", "usePackedStack", "(", "MF", ")", "||", "BackChain", ")", "getOrCreateFramePointerSaveIndex", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "(", "MFFrame", ".", "estimateStackSize", "(", "MF", ")", "+", "SystemZMC", "::", "ELFCallFrameSize", ")", ";", "int64_t", "MaxArgOffset", "=", "0", ";", "for", "(", "int", "I", "=", "MFFrame", ".", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "if", "(", "MFFrame", ".", "getObjectOffset", "(", "I", ")", ">=", "0", ")", "{", "int64_t", "ArgOffset", "=", "MFFrame", ".", "getObjectOffset", "(", "I", ")", "+", "MFFrame", ".", "getObjectSize", "(", "I", ")", ";", "MaxArgOffset", "=", "std", "::", "max", "(", "MaxArgOffset", ",", "ArgOffset", ")", ";", "}", "uint64_t", "MaxReach", "=", "StackSize", "+", "MaxArgOffset", ";", "if", "(", "!", "isUInt", "<", "12", ">", "(", "MaxReach", ")", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "Align", "(", "8", ")", ",", "false", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "Align", "(", "8", ")", ",", "false", ")", ")", ";", "}", "if", "(", "MF", ".", "front", "(", ")", ".", "isLiveIn", "(", "SystemZ", "::", "R6D", ")", "&&", "ZFI", "->", "getRestoreGPRRegs", "(", ")", ".", "LowGPR", "!=", "SystemZ", "::", "R6D", ")", "for", "(", "auto", "&", "MO", ":", "MRI", "->", "use_nodbg_operands", "(", "SystemZ", "::", "R6D", ")", ")", "MO", ".", "setIsKill", "(", "false", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "\"backchain\"", "SystemZMC::ELFCallFrameSize", "0", "0", "0", "12", "8", "8", "8", "8", "SystemZ::R6D", "SystemZ::R6D", "SystemZ::R6D" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "AssumptionCacheTracker", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "if", "(", "!", "ExpandDiv64InIR", ")", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "bool", "little", ",", "const", "MipsTargetMachine", "&", "TM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "MipsDefault", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSoftFloat", "(", "false", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFPXX", "(", "false", ")", ",", "NoABICalls", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "UseOddSPReg", "(", "true", ")", ",", "IsNaN2008bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "HasCnMips", "(", "false", ")", ",", "HasMips3_32", "(", "false", ")", ",", "HasMips3_32r2", "(", "false", ")", ",", "HasMips4_32", "(", "false", ")", ",", "HasMips4_32r2", "(", "false", ")", ",", "HasMips5_32r2", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "InMips16HardFloat", "(", "Mips16HardFloat", ")", ",", "InMicroMipsMode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "HasDSPR3", "(", "false", ")", ",", "AllowMixed16_32", "(", "Mixed16_32", "|", "Mips_Os16", ")", ",", "Os16", "(", "Mips_Os16", ")", ",", "HasMSA", "(", "false", ")", ",", "UseTCCInDIV", "(", "false", ")", ",", "HasSym32", "(", "false", ")", ",", "HasEVA", "(", "false", ")", ",", "DisableMadd4", "(", "false", ")", ",", "HasMT", "(", "false", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "MipsInstrInfo", "::", "create", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ",", "TM", ")", ")", ")", ",", "FrameLowering", "(", "MipsFrameLowering", "::", "create", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "MipsTargetLowering", "::", "create", "(", "TM", ",", "*", "this", ")", ")", "{", "if", "(", "MipsArchVersion", "==", "MipsDefault", ")", "MipsArchVersion", "=", "Mips32", ";", "if", "(", "MipsArchVersion", "==", "Mips1", ")", "report_fatal_error", "(", "\"Code generation for MIPS-I is not implemented\"", ",", "false", ")", ";", "if", "(", "MipsArchVersion", "==", "Mips5", ")", "report_fatal_error", "(", "\"Code generation for MIPS-V is not implemented\"", ",", "false", ")", ";", "assert", "(", "(", "(", "!", "isGP64bit", "(", ")", "&&", "isABI_O32", "(", ")", ")", "||", "(", "isGP64bit", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "hasMSA", "(", ")", "&&", "!", "isFP64bit", "(", ")", ")", "report_fatal_error", "(", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", ",", "false", ")", ";", "if", "(", "!", "isABI_O32", "(", ")", "&&", "!", "useOddSPReg", "(", ")", ")", "report_fatal_error", "(", "\"-mattr=+nooddspreg requires the O32 ABI.\"", ",", "false", ")", ";", "if", "(", "IsFPXX", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", "report_fatal_error", "(", "\"FPXX is not permitted for the N32/N64 ABI's.\"", ",", "false", ")", ";", "if", "(", "hasMips32r6", "(", ")", ")", "{", "StringRef", "ISA", "=", "hasMips64r6", "(", ")", "?", "\"MIPS64r6\"", ":", "\"MIPS32r6\"", ";", "assert", "(", "isFP64bit", "(", ")", ")", ";", "assert", "(", "isNaN2008", "(", ")", ")", ";", "if", "(", "hasDSP", "(", ")", ")", "report_fatal_error", "(", "ISA", "+", "\" is not compatible with the DSP ASE\"", ",", "false", ")", ";", "}", "if", "(", "NoABICalls", "&&", "TM", ".", "isPositionIndependent", "(", ")", ")", "report_fatal_error", "(", "\"position-independent code requires '-mabicalls'\"", ")", ";", "if", "(", "isABI_N64", "(", ")", "&&", "!", "TM", ".", "isPositionIndependent", "(", ")", "&&", "!", "hasSym32", "(", ")", ")", "NoABICalls", "=", "true", ";", "UseSmallSection", "=", "GPOpt", ";", "if", "(", "!", "NoABICalls", "&&", "GPOpt", ")", "{", "errs", "(", ")", "<<", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "<<", "\"\\n\"", ";", "UseSmallSection", "=", "false", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Code generation for MIPS-I is not implemented\"", "Mips", "Mips", "\"Code generation for MIPS-V is not implemented\"", "\"Invalid Arch & ABI pair.\"", "\"MSA requires a 64-bit FPU register file (FR=1 mode). \"", "\"See -mattr=+fp64.\"", "\"-mattr=+nooddspreg requires the O32 ABI.\"", "\"FPXX is not permitted for the N32/N64 ABI's.\"", "Mips", "Mips", "\"MIPS64r6\"", "\"MIPS32r6\"", "\" is not compatible with the DSP ASE\"", "\"position-independent code requires '-mabicalls'\"", "\"warning: cannot use small-data accesses for '-mabicalls'\"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "mn10300_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "rtx", "symbol", ";", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "!", "MEM_P", "(", "rtl", ")", ")", "return", ";", "symbol", "=", "XEXP", "(", "rtl", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", ";", "if", "(", "flag_pic", ")", "SYMBOL_REF_FLAG", "(", "symbol", ")", "=", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ";", "}", "</s>" ]

[ "If", "using", "PIC", ",", "mark", "a", "SYMBOL_REF", "for", "a", "non-global", "symbol", "so", "that", "we", "may", "access", "it", "using", "GOTOFF", "instead", "of", "GOT", "." ]

[ "mn10300", "0" ]

[]

[ "<s>", "int", "hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ")", "return", "(", "regno", "&", "1", ")", "==", "0", "&&", "GPR_P", "(", "regno", ")", ";", "else", "return", "1", ";", "}", "</s>" ]

[ "Value", "is", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

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

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "Expr", "==", "0", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "RISCV", "0", "0" ]

[]

[ "<s>", "virtual", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Cpu0 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "Cpu0", "\"Cpu0 Assembly Printer\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "LOAD_STACK_GUARD", ")", "{", "expandLoadStackGuard", "(", "MI", ")", ";", "MI", ".", "getParent", "(", ")", "->", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MEMCPY", ")", "{", "expandMEMCPY", "(", "MI", ")", ";", "return", "true", ";", "}", "if", "(", "!", "MI", ".", "isCopy", "(", ")", "||", "Subtarget", ".", "dontWidenVMOVS", "(", ")", "||", "!", "Subtarget", ".", "hasFP64", "(", ")", ")", "return", "false", ";", "Register", "DstRegS", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "SrcRegS", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "ARM", "::", "SPRRegClass", ".", "contains", "(", "DstRegS", ",", "SrcRegS", ")", ")", "return", "false", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "unsigned", "DstRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "DstRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "unsigned", "SrcRegD", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcRegS", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DstRegD", "||", "!", "SrcRegD", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "definesRegister", "(", "DstRegD", ",", "TRI", ")", "||", "MI", ".", "readsRegister", "(", "DstRegD", ",", "TRI", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"widening: \"", "<<", "MI", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "int", "ImpDefIdx", "=", "MI", ".", "findRegisterDefOperandIdx", "(", "DstRegD", ")", ";", "if", "(", "ImpDefIdx", "!=", "-", "1", ")", "MI", ".", "removeOperand", "(", "ImpDefIdx", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "ARM", "::", "VMOVD", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DstRegD", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setReg", "(", "SrcRegD", ")", ";", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsUndef", "(", ")", ";", "MIB", ".", "addReg", "(", "SrcRegS", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "false", ")", ";", "MI", ".", "addRegisterKilled", "(", "SrcRegS", ",", "TRI", ",", "true", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"replaced by: \"", "<<", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::MEMCPY", "0", "1", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0", "\"widening: \"", "1", "ARM::VMOVD", "0", "1", "ARMCC::AL", "1", "1", "1", "\"replaced by: \"" ]

[]

[ "<s>", "bool", "nonpic_symbol_mentioned_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "PC", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTPLT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTTPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_DTPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PLT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PCREL", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_SYMOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PCREL_SYMOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTFUNCDESC", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFFFUNCDESC", ")", ")", "return", "false", ";", "const", "char", "*", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "int", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "for", "(", "int", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "nonpic_symbol_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "nonpic_symbol_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "references", "a", "SYMBOL_REF", "or", "LABEL_REF", "whose", "symbol", "is", "n't", "protected", "by", "a", "PIC", "unspec", "." ]

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

[]

[ "<s>", "static", "bool", "vspltis_constant", "(", "rtx", "op", ",", "unsigned", "step", ",", "unsigned", "copies", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "enum", "machine_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "i", ";", "unsigned", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "unsigned", "bitsize", "=", "GET_MODE_BITSIZE", "(", "inner", ")", ";", "unsigned", "mask", "=", "GET_MODE_MASK", "(", "inner", ")", ";", "rtx", "last", "=", "CONST_VECTOR_ELT", "(", "op", ",", "nunits", "-", "1", ")", ";", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "last", ")", ";", "HOST_WIDE_INT", "splat_val", "=", "val", ";", "HOST_WIDE_INT", "msb_val", "=", "val", ">", "0", "?", "0", ":", "-", "1", ";", "for", "(", "i", "=", "2", ";", "i", "<=", "copies", ";", "i", "*=", "2", ")", "{", "HOST_WIDE_INT", "small_val", ";", "bitsize", "/=", "2", ";", "small_val", "=", "splat_val", ">>", "bitsize", ";", "mask", ">>=", "bitsize", ";", "if", "(", "splat_val", "!=", "(", "(", "small_val", "<<", "bitsize", ")", "|", "(", "small_val", "&", "mask", ")", ")", ")", "return", "false", ";", "splat_val", "=", "small_val", ";", "}", "if", "(", "EASY_VECTOR_15", "(", "splat_val", ")", ")", ";", "else", "if", "(", "EASY_VECTOR_15_ADD_SELF", "(", "splat_val", ")", "&&", "(", "splat_val", ">=", "0", "||", "(", "step", "==", "1", "&&", "copies", "==", "1", ")", ")", ")", ";", "else", "return", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nunits", "-", "1", ";", "++", "i", ")", "{", "HOST_WIDE_INT", "desired_val", ";", "if", "(", "(", "(", "i", "+", "1", ")", "&", "(", "step", "-", "1", ")", ")", "==", "0", ")", "desired_val", "=", "val", ";", "else", "desired_val", "=", "msb_val", ";", "if", "(", "desired_val", "!=", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "can", "be", "synthesized", "with", "a", "particular", "vspltisb", ",", "vspltish", "or", "vspltisw", "instruction", ".", "OP", "is", "a", "CONST_VECTOR", ".", "Which", "instruction", "is", "used", "depends", "on", "STEP", "and", "COPIES", ",", "one", "of", "which", "will", "be", "1", ".", "If", "COPIES", ">", "1", ",", "all", "items", "are", "set", "to", "the", "same", "value", "and", "contain", "COPIES", "replicas", "of", "the", "vsplt", "'s", "operand", ";", "if", "STEP", ">", "1", ",", "one", "in", "STEP", "elements", "is", "set", "to", "the", "vsplt", "'s", "operand", "and", "the", "others", "are", "set", "to", "the", "value", "of", "the", "operand", "'s", "msb", "." ]

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

[]

[ "<s>", "static", "inline", "void", "s390_indirect_branch_attrvalue", "(", "tree", "attr", ",", "enum", "indirect_branch", "*", "val", ")", "{", "const", "char", "*", "str", "=", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "TREE_VALUE", "(", "attr", ")", ")", ")", ";", "if", "(", "strcmp", "(", "str", ",", "\"keep\"", ")", "==", "0", ")", "*", "val", "=", "indirect_branch_keep", ";", "else", "if", "(", "strcmp", "(", "str", ",", "\"thunk\"", ")", "==", "0", ")", "*", "val", "=", "indirect_branch_thunk", ";", "else", "if", "(", "strcmp", "(", "str", ",", "\"thunk-inline\"", ")", "==", "0", ")", "*", "val", "=", "indirect_branch_thunk_inline", ";", "else", "if", "(", "strcmp", "(", "str", ",", "\"thunk-extern\"", ")", "==", "0", ")", "*", "val", "=", "indirect_branch_thunk_extern", ";", "}", "</s>" ]

[ "Set", "VAL", "to", "correct", "enum", "value", "according", "to", "the", "indirect-branch", "or", "function-return", "attribute", "in", "ATTR", "." ]

[ "s390", "\"keep\"", "0", "\"thunk\"", "0", "\"thunk-inline\"", "0", "\"thunk-extern\"", "0" ]

[]

[ "<s>", "static", "void", "or1k_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "rtx", "operand", "=", "x", ";", "switch", "(", "code", ")", "{", "case", "'#'", ":", "if", "(", "final_sequence", "==", "NULL", ")", "fputs", "(", "\"\\n\\t l.nop\\n\"", ",", "file", ")", ";", "break", ";", "case", "'r'", ":", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "else", "if", "(", "x", "==", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", ")", ")", "fprintf", "(", "file", ",", "\"r0\"", ")", ";", "else", "output_operand_lossage", "(", "\"invalid %%r value\"", ")", ";", "break", ";", "case", "'H'", ":", "if", "(", "REG_P", "(", "x", ")", ")", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "+", "1", "]", ")", ";", "else", "output_operand_lossage", "(", "\"invalid %%H value\"", ")", ";", "break", ";", "case", "'h'", ":", "print_reloc", "(", "file", ",", "x", ",", "0", ",", "RKIND_HI", ")", ";", "break", ";", "case", "'L'", ":", "print_reloc", "(", "file", ",", "x", ",", "0", ",", "RKIND_LO", ")", ";", "break", ";", "case", "'P'", ":", "if", "(", "!", "flag_pic", "||", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", "output_addr_const", "(", "file", ",", "x", ")", ";", "else", "output_addr_reloc", "(", "file", ",", "x", ",", "0", ",", "\"plt\"", ")", ";", "break", ";", "case", "0", ":", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "operand", ")", ">", "31", ")", "internal_error", "(", "\"internal error: bad register: %d\"", ",", "REGNO", "(", "operand", ")", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "XEXP", "(", "operand", ",", "0", ")", ")", ",", "XEXP", "(", "operand", ",", "0", ")", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "case", "LABEL_REF", ":", "output_asm_label", "(", "operand", ")", ";", "break", ";", "default", ":", "if", "(", "CONSTANT_P", "(", "operand", ")", ")", "output_addr_const", "(", "file", ",", "operand", ")", ";", "else", "internal_error", "(", "\"unexpected operand: %d\"", ",", "GET_CODE", "(", "operand", ")", ")", ";", "break", ";", "}", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown operand letter: '%c'\"", ",", "code", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Worker", "for", "TARGET_PRINT_OPERAND", ".", "Print", "operand", "X", ",", "an", "RTX", ",", "to", "the", "file", "FILE", ".", "The", "output", "is", "formed", "as", "expected", "by", "the", "OpenRISC", "assember", ".", "CODE", "is", "the", "letter", "following", "a", "'", "%", "'", "in", "an", "instrunction", "template", "used", "to", "control", "the", "RTX", "output", ".", "Example", "(", "s", ")", ":", "CODE", "RTX", "OUTPUT", "COMMENT", "0", "(", "reg", ":", "SI", "3", ")", "r3", "output", "an", "operand", "r", "(", "reg", ":", "SI", "3", ")", "r3", "output", "a", "register", "or", "const", "zero", "H", "(", "reg", ":", "SI", "3", ")", "r4", "output", "the", "high", "pair", "register", "h", "(", "symbol_ref", ":", "SI", "(", "``", "x", "''", ")", ")", "ha", "(", "x", ")", "output", "a", "signed", "high", "relocation", "L", "(", "symbol_ref", ":", "SI", "(", "``", "x", "''", ")", ")", "lo", "(", "x", ")", "output", "a", "low", "relocation", "Note", ",", "'", "#", "'", "is", "a", "special", "code", "used", "to", "fill", "the", "branch", "delay", "slot", "with", "an", "l.nop", "instruction", ".", "The", "l.nop", "(", "no-op", ")", "instruction", "is", "only", "outputted", "when", "the", "delay", "slot", "has", "not", "been", "filled", "." ]

[ "or1k", "\"\\n\\t l.nop\\n\"", "\"%s\"", "\"r0\"", "\"invalid %%r value\"", "\"%s\"", "1", "\"invalid %%H value\"", "0", "0", "0", "\"plt\"", "0", "31", "\"internal error: bad register: %d\"", "\"%s\"", "0", "0", "\"unexpected operand: %d\"", "\"unknown operand letter: '%c'\"" ]

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "readlaneVGPRToSGPR", "(", "unsigned", "SrcReg", ",", "MachineInstr", "&", "UseMI", ",", "MachineRegisterInfo", "&", "MRI", ")", "const", "{", "const", "TargetRegisterClass", "*", "VRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "const", "TargetRegisterClass", "*", "SRC", "=", "RI", ".", "getEquivalentSGPRClass", "(", "VRC", ")", ";", "Register", "DstReg", "=", "MRI", ".", "createVirtualRegister", "(", "SRC", ")", ";", "unsigned", "SubRegs", "=", "RI", ".", "getRegSizeInBits", "(", "*", "VRC", ")", "/", "32", ";", "if", "(", "RI", ".", "hasAGPRs", "(", "VRC", ")", ")", "{", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "VRC", ")", ";", "Register", "NewSrcReg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewSrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "SrcReg", "=", "NewSrcReg", ";", "}", "if", "(", "SubRegs", "==", "1", ")", "{", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", "DstReg", ";", "}", "SmallVector", "<", "unsigned", ",", "8", ">", "SRegs", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "Register", "SGPR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ")", ";", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "V_READFIRSTLANE_B32", ")", ",", "SGPR", ")", ".", "addReg", "(", "SrcReg", ",", "0", ",", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "SRegs", ".", "push_back", "(", "SGPR", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "UseMI", ".", "getParent", "(", ")", ",", "UseMI", ",", "UseMI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "AMDGPU", "::", "REG_SEQUENCE", ")", ",", "DstReg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "SubRegs", ";", "++", "i", ")", "{", "MIB", ".", "addReg", "(", "SRegs", "[", "i", "]", ")", ";", "MIB", ".", "addImm", "(", "RI", ".", "getSubRegFromChannel", "(", "i", ")", ")", ";", "}", "return", "DstReg", ";", "}", "</s>" ]

[ "Copy", "a", "value", "from", "a", "VGPR", "(", "SrcReg", ")", "to", "SGPR", "." ]

[ "AMDGPU", "SI", "32", "1", "AMDGPU::V_READFIRSTLANE_B32", "8", "0", "AMDGPU::SGPR_32RegClass", "AMDGPU::V_READFIRSTLANE_B32", "0", "AMDGPU::REG_SEQUENCE", "0" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "const", "M68kSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "M68kSubtarget", ">", "(", ")", ";", "M68kMachineFunctionInfo", "*", "MxFI", "=", "MF", ".", "getInfo", "<", "M68kMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MxFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "==", "0", ")", "return", "false", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "const", "M68kInstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "M68k", "::", "LEA32q", ")", ",", "GlobalBaseReg", ")", ".", "addExternalSymbol", "(", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "M68kII", "::", "MO_GOTPCREL", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "M68k", "M68k", "0", "M68k", "M68k::LEA32q", "\"_GLOBAL_OFFSET_TABLE_\"", "M68kII::MO_GOTPCREL" ]

[]

[ "<s>", "void", "RV16KPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createRV16KExpandPseudoPass", "(", ")", ",", "false", ",", "true", ")", ";", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

[ "RV16K", "RV16K", "RV16K" ]

[]

[ "<s>", "inline", "bool", "vgpr_1reg_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", "||", "mode", "==", "HImode", "||", "mode", "==", "QImode", "||", "mode", "==", "V64QImode", "||", "mode", "==", "V64HImode", "||", "mode", "==", "V64SImode", "||", "mode", "==", "V64HFmode", "||", "mode", "==", "V64SFmode", "||", "mode", "==", "BImode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "is", "valid", "for", "1", "VGPR", "register", "." ]

[ "gcn" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "ARMAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "!", "STI", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "return", "None", ";", "unsigned", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Case", "(", "\"BFD_RELOC_NONE\"", ",", "ELF", "::", "R_ARM_NONE", ")", ".", "Case", "(", "\"BFD_RELOC_8\"", ",", "ELF", "::", "R_ARM_ABS8", ")", ".", "Case", "(", "\"BFD_RELOC_16\"", ",", "ELF", "::", "R_ARM_ABS16", ")", ".", "Case", "(", "\"BFD_RELOC_32\"", ",", "ELF", "::", "R_ARM_ABS32", ")", ".", "Default", "(", "-", "1u", ")", ";", "if", "(", "Type", "==", "-", "1u", ")", "return", "None", ";", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "ARM", "ARM", "\"BFD_RELOC_NONE\"", "ARM", "\"BFD_RELOC_8\"", "ARM", "\"BFD_RELOC_16\"", "ARM", "\"BFD_RELOC_32\"", "ARM", "1u", "1u" ]

[]

[ "<s>", "bool", "AArch64MIPeepholeOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected to be run on SSA form!\"", ")", ";", "bool", "Changed", "=", "false", ";", "SmallSetVector", "<", "MachineInstr", "*", ",", "8", ">", "ToBeRemoved", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "ANDWrr", ":", "Changed", "=", "visitAND", "<", "uint32_t", ">", "(", "AArch64", "::", "ANDWri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ANDXrr", ":", "Changed", "=", "visitAND", "<", "uint64_t", ">", "(", "AArch64", "::", "ANDXri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ORRWrs", ":", "Changed", "=", "visitORR", "(", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ADDWrr", ":", "Changed", "=", "visitADDSUB", "<", "uint32_t", ">", "(", "AArch64", "::", "ADDWri", ",", "AArch64", "::", "SUBWri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "SUBWrr", ":", "Changed", "=", "visitADDSUB", "<", "uint32_t", ">", "(", "AArch64", "::", "SUBWri", ",", "AArch64", "::", "ADDWri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ADDXrr", ":", "Changed", "=", "visitADDSUB", "<", "uint64_t", ">", "(", "AArch64", "::", "ADDXri", ",", "AArch64", "::", "SUBXri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "SUBXrr", ":", "Changed", "=", "visitADDSUB", "<", "uint64_t", ">", "(", "AArch64", "::", "SUBXri", ",", "AArch64", "::", "ADDXri", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ADDSWrr", ":", "Changed", "=", "visitADDSSUBS", "<", "uint32_t", ">", "(", "{", "AArch64", "::", "ADDWri", ",", "AArch64", "::", "ADDSWri", "}", ",", "{", "AArch64", "::", "SUBWri", ",", "AArch64", "::", "SUBSWri", "}", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "SUBSWrr", ":", "Changed", "=", "visitADDSSUBS", "<", "uint32_t", ">", "(", "{", "AArch64", "::", "SUBWri", ",", "AArch64", "::", "SUBSWri", "}", ",", "{", "AArch64", "::", "ADDWri", ",", "AArch64", "::", "ADDSWri", "}", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "ADDSXrr", ":", "Changed", "=", "visitADDSSUBS", "<", "uint64_t", ">", "(", "{", "AArch64", "::", "ADDXri", ",", "AArch64", "::", "ADDSXri", "}", ",", "{", "AArch64", "::", "SUBXri", ",", "AArch64", "::", "SUBSXri", "}", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "case", "AArch64", "::", "SUBSXrr", ":", "Changed", "=", "visitADDSSUBS", "<", "uint64_t", ">", "(", "{", "AArch64", "::", "SUBXri", ",", "AArch64", "::", "SUBSXri", "}", ",", "{", "AArch64", "::", "ADDXri", ",", "AArch64", "::", "ADDSXri", "}", ",", "MI", ",", "ToBeRemoved", ")", ";", "break", ";", "}", "}", "}", "for", "(", "MachineInstr", "*", "MI", ":", "ToBeRemoved", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"Expected to be run on SSA form!\"", "8", "AArch64::ANDWrr", "AArch64::ANDWri", "AArch64::ANDXrr", "AArch64::ANDXri", "AArch64::ORRWrs", "AArch64::ADDWrr", "AArch64::ADDWri", "AArch64::SUBWri", "AArch64::SUBWrr", "AArch64::SUBWri", "AArch64::ADDWri", "AArch64::ADDXrr", "AArch64::ADDXri", "AArch64::SUBXri", "AArch64::SUBXrr", "AArch64::SUBXri", "AArch64::ADDXri", "AArch64::ADDSWrr", "AArch64::ADDWri", "AArch64::ADDSWri", "AArch64::SUBWri", "AArch64::SUBSWri", "AArch64::SUBSWrr", "AArch64::SUBWri", "AArch64::SUBSWri", "AArch64::ADDWri", "AArch64::ADDSWri", "AArch64::ADDSXrr", "AArch64::ADDXri", "AArch64::ADDSXri", "AArch64::SUBXri", "AArch64::SUBSXri", "AArch64::SUBSXrr", "AArch64::SUBXri", "AArch64::SUBSXri", "AArch64::ADDXri", "AArch64::ADDSXri" ]

[]

[ "<s>", "static", "void", "csky_setup_incoming_varargs", "(", "cumulative_args_t", "pcum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "cumulative_args_t", "local_cum_v", "=", "pack_cumulative_args", "(", "&", "local_cum", ")", ";", "int", "regs_to_push", ";", "cfun", "->", "machine", "->", "uses_anonymous_args", "=", "1", ";", "local_cum", "=", "*", "pcum", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "csky_function_arg_advance", "(", "local_cum_v", ",", "arg", ")", ";", "regs_to_push", "=", "CSKY_NPARM_REGS", "-", "local_cum", ".", "reg", ";", "if", "(", "regs_to_push", ")", "*", "pretend_size", "=", "regs_to_push", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", ".", "On", "C-Sky", "the", "copy", "from", "the", "argument", "registers", "to", "the", "stack", "is", "emitted", "by", "the", "prologue", "hooks", ",", "so", "here", "we", "just", "have", "to", "note", "how", "much", "stack", "space", "to", "save", "." ]

[ "csky", "1" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", "&&", "ExtraCode", "[", "0", "]", "!=", "'a'", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "O", "<<", "\"[\"", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "AArch64", "AArch64", "0", "0", "\"unexpected inline asm memory operand\"", "\"[\"", "AArch64", "\"]\"" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "leaveMBB", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"+++ Leaving \"", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "\"\\n\"", ";", ")", ";", "advanceTo", "(", "MBB", "->", "getFirstTerminator", "(", ")", ")", ";", "}", "</s>" ]

[ "Tell", "the", "strategy", "that", "current", "MBB", "is", "done", "." ]

[ "SystemZ", "SystemZ", "\"+++ Leaving \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "addPreISel", "(", ")", "override", "{", "addPass", "(", "createFlattenCFGPass", "(", ")", ")", ";", "addPass", "(", "createStructurizeCFGPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

[ "TGSI" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "assert", "(", "0", "&&", "\"relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "0", "\"relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "k_Token", ";", "}", "</s>" ]

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "Mips" ]

[]

[ "<s>", "static", "AMDGPUOperand", "::", "Ptr", "CreateReg", "(", "const", "AMDGPUAsmParser", "*", "AsmParser", ",", "unsigned", "RegNo", ",", "SMLoc", "S", ",", "SMLoc", "E", ",", "bool", "ForceVOP3", ")", "{", "auto", "Op", "=", "llvm", "::", "make_unique", "<", "AMDGPUOperand", ">", "(", "Register", ",", "AsmParser", ")", ";", "Op", "->", "Reg", ".", "RegNo", "=", "RegNo", ";", "Op", "->", "Reg", ".", "Mods", "=", "Modifiers", "(", ")", ";", "Op", "->", "Reg", ".", "IsForcedVOP3", "=", "ForceVOP3", ";", "Op", "->", "StartLoc", "=", "S", ";", "Op", "->", "EndLoc", "=", "E", ";", "return", "Op", ";", "}", "</s>" ]

[ "CreateReg", "-", "Allocate", "a", "single", "virtual", "register", "for", "the", "given", "type", "." ]

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

[]

[ "<s>", "bool", "SIInsertWaits", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changes", "=", "false", ";", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "static_cast", "<", "const", "SIRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "WaitedOn", "=", "ZeroCounts", ";", "LastIssued", "=", "ZeroCounts", ";", "LastOpcodeType", "=", "OTHER", ";", "LastInstWritesM0", "=", "false", ";", "ReturnsVoid", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "returnsVoid", "(", ")", ";", "memset", "(", "&", "UsedRegs", ",", "0", ",", "sizeof", "(", "UsedRegs", ")", ")", ";", "memset", "(", "&", "DefinedRegs", ",", "0", ",", "sizeof", "(", "DefinedRegs", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "ST", ".", "getGeneration", "(", ")", "<=", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ")", "{", "if", "(", "TII", "->", "isSMRD", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "VCCZCorrupt", "=", "true", ";", "}", "else", "if", "(", "!", "hasOutstandingLGKM", "(", ")", "&&", "I", "->", "modifiesRegister", "(", "AMDGPU", "::", "VCC", ",", "TRI", ")", ")", "{", "VCCZCorrupt", "=", "false", ";", "}", "if", "(", "readsVCCZ", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "VCCZCorrupt", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Inserting vccz bug work-around before: \"", "<<", "*", "I", "<<", "'\\n'", ")", ";", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "AMDGPU", "::", "VCC", ")", ".", "addReg", "(", "AMDGPU", "::", "VCC", ")", ";", "}", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_BARRIER", ")", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "LastIssued", ")", ";", "else", "Changes", "|=", "insertWait", "(", "MBB", ",", "I", ",", "handleOperands", "(", "*", "I", ")", ")", ";", "pushInstruction", "(", "MBB", ",", "I", ")", ";", "handleSendMsg", "(", "MBB", ",", "I", ")", ";", "}", "Changes", "|=", "insertWait", "(", "MBB", ",", "MBB", ".", "getFirstTerminator", "(", ")", ",", "LastIssued", ")", ";", "if", "(", "!", "ReturnsVoid", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "S_ENDPGM", ")", "I", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "Changes", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU", "AMDGPU", "SI", "0", "0", "AMDGPU", "AMDGPU::VCC", "\"Inserting vccz bug work-around before: \"", "AMDGPU::S_MOV_B64", "AMDGPU::VCC", "AMDGPU::VCC", "AMDGPU::S_BARRIER", "AMDGPU::S_ENDPGM" ]

[]

[ "<s>", "static", "struct", "bundle_state", "*", "get_free_bundle_state", "(", "void", ")", "{", "struct", "bundle_state", "*", "result", ";", "if", "(", "free_bundle_state_chain", "!=", "NULL", ")", "{", "result", "=", "free_bundle_state_chain", ";", "free_bundle_state_chain", "=", "result", "->", "next", ";", "}", "else", "{", "result", "=", "XNEW", "(", "struct", "bundle_state", ")", ";", "result", "->", "dfa_state", "=", "xmalloc", "(", "dfa_state_size", ")", ";", "result", "->", "allocated_states_chain", "=", "allocated_bundle_states_chain", ";", "allocated_bundle_states_chain", "=", "result", ";", "}", "result", "->", "unique_num", "=", "bundle_states_num", "++", ";", "return", "result", ";", "}", "</s>" ]

[ "The", "following", "function", "returns", "a", "free", "bundle", "state", "." ]

[ "ia64" ]

[]

[ "<s>", "bool", "Z80AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Unimplemented\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "SITargetLowering", "::", "getTypeLegalizationCost", "(", "const", "DataLayout", "&", "DL", ",", "Type", "*", "Ty", ")", "const", "{", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "Cost", "=", "TargetLoweringBase", "::", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "auto", "Size", "=", "DL", ".", "getTypeSizeInBits", "(", "Ty", ")", ";", "if", "(", "Size", "<=", "256", ")", "return", "Cost", ";", "Cost", ".", "first", "=", "(", "Size", "+", "255", ")", "/", "256", ";", "return", "Cost", ";", "}", "</s>" ]

[ "Estimate", "the", "cost", "of", "type-legalization", "and", "the", "legalized", "type", "." ]

[ "AMDGPU", "SI", "256", "255", "256" ]

[]