Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "unsigned", "int", "tilegx_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "alignment", "<", "PARM_BOUNDARY", ")", "alignment", "=", "PARM_BOUNDARY", ";", "if", "(", "alignment", ">", "STACK_BOUNDARY", ")", "alignment", "=", "STACK_BOUNDARY", ";", "return", "alignment", ";", "}", "</s>" ]

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

[ "tilegx" ]

[]

[ "<s>", "Register", "getExceptionSelectorRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "override", "{", "return", "SP", "::", "I1", ";", "}", "</s>" ]

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

[ "Sparc", "SP::I1" ]

[]

[ "<s>", "void", "s390_expand_cs_hqi", "(", "enum", "machine_mode", "mode", ",", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "cmp", ",", "rtx", "new", ")", "{", "struct", "alignment_context", "ac", ";", "rtx", "cmpv", ",", "newv", ",", "val", ",", "resv", ",", "cc", ";", "rtx", "res", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "csloop", "=", "gen_label_rtx", "(", ")", ";", "rtx", "csend", "=", "gen_label_rtx", "(", ")", ";", "gcc_assert", "(", "register_operand", "(", "target", ",", "VOIDmode", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ",", "mode", ")", ";", "if", "(", "!", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "cmp", ")", ")", ")", "cmp", "=", "s390_expand_mask_and_shift", "(", "cmp", ",", "mode", ",", "ac", ".", "shift", ")", ";", "if", "(", "!", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "new", ")", ")", ")", "new", "=", "s390_expand_mask_and_shift", "(", "new", ",", "mode", ",", "ac", ".", "shift", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "ac", ".", "memsi", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "emit_label", "(", "csloop", ")", ";", "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "cmp", ")", ")", "{", "cmpv", "=", "force_reg", "(", "SImode", ",", "val", ")", ";", "store_bit_field", "(", "cmpv", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "SImode", ",", "cmp", ")", ";", "}", "else", "cmpv", "=", "force_reg", "(", "SImode", ",", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "cmp", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "new", ")", ")", "{", "newv", "=", "force_reg", "(", "SImode", ",", "val", ")", ";", "store_bit_field", "(", "newv", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "SImode", ",", "new", ")", ";", "}", "else", "newv", "=", "force_reg", "(", "SImode", ",", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "new", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ")", ";", "emit_insn", "(", "gen_sync_compare_and_swap_ccsi", "(", "res", ",", "ac", ".", "memsi", ",", "cmpv", ",", "newv", ")", ")", ";", "s390_emit_jump", "(", "csend", ",", "s390_emit_compare", "(", "EQ", ",", "cmpv", ",", "ac", ".", "memsi", ")", ")", ";", "resv", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "res", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cc", "=", "s390_emit_compare", "(", "NE", ",", "resv", ",", "val", ")", ";", "emit_move_insn", "(", "val", ",", "resv", ")", ";", "s390_emit_jump", "(", "csloop", ",", "cc", ")", ";", "emit_label", "(", "csend", ")", ";", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "res", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ",", "1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "compare", "and", "swap", "operation", "for", "HImode", "and", "QImode", ".", "MEM", "is", "the", "memory", "location", ",", "CMP", "the", "old", "value", "to", "compare", "MEM", "with", "and", "NEW", "the", "value", "to", "set", "if", "CMP", "==", "MEM", ".", "CMP", "is", "never", "in", "memory", "for", "compare_and_swap_cc", "because", "expand_bool_compare_and_swap", "puts", "it", "into", "a", "register", "for", "later", "compare", "." ]

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

[]

[ "<s>", "bool", "SICFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "&", "MF", "->", "front", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "SIC", "::", "L", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "0", "SIC::L" ]

[]

[ "<s>", "void", "PTXPassConfig", "::", "addOptimizedRegAlloc", "(", "FunctionPass", "*", "RegAllocPass", ")", "{", "addFastRegAlloc", "(", "RegAllocPass", ")", ";", "}", "</s>" ]

[ "addOptimizedRegAlloc", "-", "Add", "passes", "related", "to", "register", "allocation", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "const", "MCExpr", "*", "R600AsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "if", "(", "const", "MCExpr", "*", "E", "=", "lowerAddrSpaceCast", "(", "TM", ",", "CV", ",", "OutContext", ")", ")", "return", "E", ";", "return", "AsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "LLVM", "Constant", "to", "an", "MCExpr", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "unsigned", "X86TTI", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "TCC_Free", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TCC_Basic", ";", "return", "TCC_Free", ";", "case", "Instruction", "::", "Store", ":", "ImmIdx", "=", "0", ";", "break", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "UDiv", ":", "case", "Instruction", "::", "SDiv", ":", "case", "Instruction", "::", "URem", ":", "case", "Instruction", "::", "SRem", ":", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "case", "Instruction", "::", "ICmp", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "if", "(", "Idx", "==", "1", ")", "return", "TCC_Free", ";", "break", ";", "case", "Instruction", "::", "Trunc", ":", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "case", "Instruction", "::", "IntToPtr", ":", "case", "Instruction", "::", "PtrToInt", ":", "case", "Instruction", "::", "BitCast", ":", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Select", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "break", ";", "}", "if", "(", "(", "Idx", "==", "ImmIdx", ")", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", "&&", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TCC_Free", ";", "return", "X86TTI", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0U", "0", "2", "0", "1", "1", "64", "32", "X86" ]

[]

[ "<s>", "static", "void", "arm_option_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "int", "flags", "=", "ptr", "->", "x_target_flags", ";", "const", "char", "*", "fpu_name", ";", "fpu_name", "=", "(", "ptr", "->", "x_arm_fpu_index", "==", "TARGET_FPU_auto", "?", "\"auto\"", ":", "all_fpus", "[", "ptr", "->", "x_arm_fpu_index", "]", ".", "name", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected arch %s\\n\"", ",", "indent", ",", "\"\"", ",", "TARGET_THUMB2_P", "(", "flags", ")", "?", "\"thumb2\"", ":", "TARGET_THUMB_P", "(", "flags", ")", "?", "\"thumb1\"", ":", "\"arm\"", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected fpu %s\\n\"", ",", "indent", ",", "\"\"", ",", "fpu_name", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_PRINT", "." ]

[ "arm", "\"auto\"", "\"%*sselected arch %s\\n\"", "\"\"", "\"thumb2\"", "\"thumb1\"", "\"arm\"", "\"%*sselected fpu %s\\n\"", "\"\"" ]

[]

[ "<s>", "bool", "MMIXPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMMIXISelDag", "(", "getMMIXTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "MMIX", "MMIX" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "usesConstantBus", "(", "const", "MCInst", "&", "Inst", ",", "unsigned", "OpIdx", ")", "{", "const", "MCOperand", "&", "MO", "=", "Inst", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "!", "isInlineConstant", "(", "Inst", ",", "OpIdx", ")", ";", "}", "return", "!", "MO", ".", "isReg", "(", ")", "||", "isSGPR", "(", "mc2PseudoReg", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "m68k_save_reg", "(", "unsigned", "int", "regno", ",", "bool", "interrupt_handler", ")", "{", "if", "(", "flag_pic", "&&", "regno", "==", "PIC_REG", ")", "{", "if", "(", "crtl", "->", "saves_all_registers", ")", "return", "true", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", ")", "return", "true", ";", "if", "(", "crtl", "->", "uses_const_pool", ")", "return", "true", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", ";", "i", "++", ")", "{", "unsigned", "int", "test", "=", "EH_RETURN_DATA_REGNO", "(", "i", ")", ";", "if", "(", "test", "==", "INVALID_REGNUM", ")", "break", ";", "if", "(", "test", "==", "regno", ")", "return", "true", ";", "}", "}", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "false", ";", "if", "(", "interrupt_handler", ")", "{", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "regno", "]", ")", "return", "true", ";", "}", "if", "(", "!", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "false", ";", "return", "!", "call_used_regs", "[", "regno", "]", ";", "}", "</s>" ]

[ "Refer", "to", "the", "array", "`", "regs_ever_live", "'", "to", "determine", "which", "registers", "to", "save", ";", "`", "regs_ever_live", "[", "I", "]", "'", "is", "nonzero", "if", "register", "number", "I", "is", "ever", "used", "in", "the", "function", ".", "This", "function", "is", "responsible", "for", "knowing", "which", "registers", "should", "not", "be", "saved", "even", "if", "used", ".", "Return", "true", "if", "we", "need", "to", "save", "REGNO", "." ]

[ "m68k", "0" ]

[]

[ "<s>", "bool", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "override", "{", "switch", "(", "ConstraintID", ")", "{", "default", ":", "errs", "(", ")", "<<", "\"ConstraintID: \"", "<<", "ConstraintID", "<<", "\"\\n\"", ";", "llvm_unreachable", "(", "\"Unexpected asm memory constraint\"", ")", ";", "case", "InlineAsm", "::", "Constraint_es", ":", "case", "InlineAsm", "::", "Constraint_m", ":", "case", "InlineAsm", "::", "Constraint_o", ":", "case", "InlineAsm", "::", "Constraint_Q", ":", "case", "InlineAsm", "::", "Constraint_Z", ":", "case", "InlineAsm", "::", "Constraint_Zy", ":", "const", "TargetRegisterInfo", "*", "TRI", "=", "PPCSubTarget", "->", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "TRC", "=", "TRI", "->", "getPointerRegClass", "(", "*", "MF", ",", "1", ")", ";", "SDLoc", "dl", "(", "Op", ")", ";", "SDValue", "RC", "=", "CurDAG", "->", "getTargetConstant", "(", "TRC", "->", "getID", "(", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "NewOp", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "COPY_TO_REGCLASS", ",", "dl", ",", "Op", ".", "getValueType", "(", ")", ",", "Op", ",", "RC", ")", ",", "0", ")", ";", "OutOps", ".", "push_back", "(", "NewOp", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "\"ConstraintID: \"", "\"\\n\"", "\"Unexpected asm memory constraint\"", "PPC", "1", "MVT::i32", "0" ]

[]

[ "<s>", "static", "void", "v850_asm_trampoline_template", "(", "FILE", "*", "f", ")", "{", "fprintf", "(", "f", ",", "\"\\tjarl .+4,r12\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tld.w 12[r12],r20\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tld.w 16[r12],r12\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tjmp [r12]\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\tnop\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.long 0\\n\"", ")", ";", "fprintf", "(", "f", ",", "\"\\t.long 0\\n\"", ")", ";", "}", "</s>" ]

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

[ "v850", "\"\\tjarl .+4,r12\\n\"", "\"\\tld.w 12[r12],r20\\n\"", "\"\\tld.w 16[r12],r12\\n\"", "\"\\tjmp [r12]\\n\"", "\"\\tnop\\n\"", "\"\\t.long 0\\n\"", "\"\\t.long 0\\n\"" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "if", "(", "TyWidth", "==", "32", ")", "return", "TTI", "::", "PSK_FastHardware", ";", "return", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

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

[ "Lanai", "32" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "WriteDXILToFile", "(", "M", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "DirectX", "DXIL" ]

[]

[ "<s>", "unsigned", "ARMFastISel", "::", "fastEmitInst_ri", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "uint64_t", "Imm", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "1", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "1", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "0", "]", ")", ")", ";", "}", "return", "ResultReg", ";", "}", "</s>" ]

[ "Emit", "a", "MachineInstr", "with", "a", "register", "operand", ",", "an", "immediate", ",", "and", "a", "result", "register", "in", "the", "given", "register", "class", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Indirect Thunks\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Indirect Thunks\"" ]

[]

[ "<s>", "static", "rtx", "emit_adjust_base_to_offset", "(", "rtx", "base", ",", "int", "offset", ")", "{", "rtx", "new_base", "=", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ";", "emit_move_insn", "(", "new_base", ",", "GEN_INT", "(", "offset", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "new_base", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "base", ",", "new_base", ")", ")", ")", ";", "return", "new_base", ";", "}", "</s>" ]

[ "Emit", "code", "to", "adjust", "BASE", "to", "OFFSET", ".", "Return", "the", "new", "base", "." ]

[ "sparc", "1" ]

[]

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

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

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "static", "void", "mips_save_restore_reg", "(", "enum", "machine_mode", "mode", ",", "int", "regno", ",", "HOST_WIDE_INT", "offset", ",", "mips_save_restore_fn", "fn", ")", "{", "rtx", "mem", ";", "mem", "=", "gen_rtx_MEM", "(", "mode", ",", "plus_constant", "(", "stack_pointer_rtx", ",", "offset", ")", ")", ";", "fn", "(", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ",", "mem", ")", ";", "}", "</s>" ]

[ "Use", "FN", "to", "save", "or", "restore", "register", "REGNO", ".", "MODE", "is", "the", "register", "'s", "mode", "and", "OFFSET", "is", "the", "offset", "of", "its", "save", "slot", "from", "the", "current", "stack", "pointer", "." ]

[ "mips" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", "rclass", ")", "{", "bool", "ret", "=", "rs6000_can_change_mode_class", "(", "from", ",", "to", ",", "rclass", ")", ";", "fprintf", "(", "stderr", ",", "\"rs6000_can_change_mode_class, return %s, from = %s, \"", "\"to = %s, rclass = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ",", "GET_MODE_NAME", "(", "from", ")", ",", "GET_MODE_NAME", "(", "to", ")", ",", "reg_class_names", "[", "rclass", "]", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_can_change_mode_class", "." ]

[ "powerpcspe", "\"rs6000_can_change_mode_class, return %s, from = %s, \"", "\"to = %s, rclass = %s\\n\"", "\"true\"", "\"false\"" ]

[]

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

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

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

[]

[ "<s>", "virtual", "void", "Initialize", "(", "MCContext", "&", "ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFile", "::", "Initialize", "(", "ctx", ",", "TM", ")", ";", "TextSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getText", "(", ")", ")", ";", "DataSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "BSSSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "ReadOnlySection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "StaticCtorSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "StaticDtorSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "LSDASection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "EHFrameSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfAbbrevSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfInfoSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLineSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfFrameSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfPubTypesSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfDebugInlineSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfStrSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLocSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfARangesSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfRangesSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfMacroInfoSection", "=", "new", "WDC65816Section", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC", "WDC" ]

[]

[ "<s>", "static", "bool", "rs6000_can_inline_p", "(", "tree", "caller", ",", "tree", "callee", ")", "{", "bool", "ret", "=", "false", ";", "tree", "caller_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "caller", ")", ";", "tree", "callee_tree", "=", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "callee", ")", ";", "if", "(", "!", "callee_tree", ")", "ret", "=", "true", ";", "else", "if", "(", "!", "caller_tree", ")", "ret", "=", "false", ";", "else", "{", "struct", "cl_target_option", "*", "caller_opts", "=", "TREE_TARGET_OPTION", "(", "caller_tree", ")", ";", "struct", "cl_target_option", "*", "callee_opts", "=", "TREE_TARGET_OPTION", "(", "callee_tree", ")", ";", "if", "(", "(", "caller_opts", "->", "x_rs6000_isa_flags", "&", "callee_opts", "->", "x_rs6000_isa_flags", ")", "==", "callee_opts", "->", "x_rs6000_isa_flags", ")", "ret", "=", "true", ";", "}", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_can_inline_p:, caller %s, callee %s, %s inline\\n\"", ",", "get_decl_name", "(", "caller", ")", ",", "get_decl_name", "(", "callee", ")", ",", "(", "ret", "?", "\"can\"", ":", "\"cannot\"", ")", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "determine", "if", "one", "function", "can", "safely", "inline", "another", "." ]

[ "rs6000", "\"rs6000_can_inline_p:, caller %s, callee %s, %s inline\\n\"", "\"can\"", "\"cannot\"" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUInstrInfo", "::", "expandPostRAPseudo", "(", "MI", ")", ";", "case", "AMDGPU", "::", "R600_EXTRACT_ELT_V2", ":", "case", "AMDGPU", "::", "R600_EXTRACT_ELT_V4", ":", "buildIndirectRead", "(", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "RI", ".", "getHWRegIndex", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ",", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "RI", ".", "getHWRegChan", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ";", "break", ";", "case", "AMDGPU", "::", "R600_INSERT_ELT_V2", ":", "case", "AMDGPU", "::", "R600_INSERT_ELT_V4", ":", "buildIndirectWrite", "(", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ",", "RI", ".", "getHWRegIndex", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ",", "MI", "->", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ",", "RI", ".", "getHWRegChan", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ";", "break", ";", "}", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "AMDGPU", "AMDGPU::R600_EXTRACT_ELT_V2", "AMDGPU::R600_EXTRACT_ELT_V4", "0", "1", "2", "1", "AMDGPU::R600_INSERT_ELT_V2", "AMDGPU::R600_INSERT_ELT_V4", "2", "1", "3", "1" ]

[]

[ "<s>", "static", "int", "alpha_issue_rate", "(", "void", ")", "{", "return", "(", "alpha_tune", "==", "PROCESSOR_EV4", "?", "2", ":", "4", ")", ";", "}", "</s>" ]

[ "Function", "to", "initialize", "the", "issue", "rate", "used", "by", "the", "scheduler", "." ]

[ "alpha", "2", "4" ]

[]

[ "<s>", "enum", "reg_class", "secondary_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "in", ")", "{", "if", "(", "(", "GET_CODE", "(", "in", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "in", ")", "==", "REG", "&&", "REGNO", "(", "in", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", "||", "(", "GET_CODE", "(", "in", ")", "==", "SUBREG", "&&", "GET_CODE", "(", "SUBREG_REG", "(", "in", ")", ")", "==", "REG", "&&", "REGNO", "(", "SUBREG_REG", "(", "in", ")", ")", ">=", "FIRST_PSEUDO_REGISTER", ")", ")", "&&", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "&&", "(", "class", "==", "ADDRESS_REGS", "||", "class", "==", "SP_REGS", "||", "class", "==", "SP_OR_ADDRESS_REGS", ")", ")", "{", "if", "(", "TARGET_AM33", ")", "return", "DATA_OR_EXTENDED_REGS", ";", "return", "DATA_REGS", ";", "}", "if", "(", "class", "!=", "SP_REGS", "&&", "class", "!=", "ADDRESS_REGS", "&&", "class", "!=", "SP_OR_ADDRESS_REGS", "&&", "class", "!=", "SP_OR_EXTENDED_REGS", "&&", "class", "!=", "ADDRESS_OR_EXTENDED_REGS", "&&", "class", "!=", "SP_OR_ADDRESS_OR_EXTENDED_REGS", "&&", "(", "in", "==", "stack_pointer_rtx", "||", "(", "GET_CODE", "(", "in", ")", "==", "PLUS", "&&", "(", "XEXP", "(", "in", ",", "0", ")", "==", "stack_pointer_rtx", "||", "XEXP", "(", "in", ",", "1", ")", "==", "stack_pointer_rtx", ")", ")", ")", ")", "return", "ADDRESS_REGS", ";", "if", "(", "GET_CODE", "(", "in", ")", "==", "PLUS", "&&", "(", "XEXP", "(", "in", ",", "0", ")", "==", "stack_pointer_rtx", "||", "XEXP", "(", "in", ",", "1", ")", "==", "stack_pointer_rtx", ")", ")", "{", "if", "(", "TARGET_AM33", ")", "return", "DATA_OR_EXTENDED_REGS", ";", "return", "DATA_REGS", ";", "}", "if", "(", "TARGET_AM33_2", "&&", "class", "==", "FP_REGS", "&&", "GET_CODE", "(", "in", ")", "==", "MEM", "&&", "!", "OK_FOR_Q", "(", "in", ")", ")", "{", "if", "(", "TARGET_AM33", ")", "return", "DATA_OR_EXTENDED_REGS", ";", "return", "DATA_REGS", ";", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "the", "class", "of", "any", "secondary", "reload", "register", "that", "is", "needed", "to", "move", "IN", "into", "a", "register", "in", "class", "CLASS", "using", "mode", "MODE", ".", "Profiling", "has", "showed", "this", "routine", "and", "its", "descendants", "account", "for", "a", "significant", "amount", "of", "compile", "time", "(", "~7", "%", ")", ".", "So", "it", "has", "been", "optimized", "to", "reduce", "redundant", "computations", "and", "eliminate", "useless", "function", "calls", ".", "It", "might", "be", "worthwhile", "to", "try", "and", "make", "this", "a", "leaf", "function", "too", "." ]

[ "mn10300", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "ARMWinCOFFStreamer", "::", "finishImpl", "(", ")", "{", "emitFrames", "(", "nullptr", ")", ";", "MCWinCOFFStreamer", "::", "finishImpl", "(", ")", ";", "}", "</s>" ]

[ "Streamer", "specific", "finalization", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "pa_som_asm_init_sections", "(", "void", ")", "{", "text_section", "=", "get_unnamed_section", "(", "0", ",", "som_output_text_section_asm_op", ",", "NULL", ")", ";", "som_readonly_data_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $LIT$\"", ")", ";", "som_one_only_readonly_data_section", "=", "get_unnamed_section", "(", "0", ",", "som_output_comdat_data_section_asm_op", ",", "\"\\t.SPACE $TEXT$\\n\"", "\"\\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,\"", "\"ACCESS=0x2c,SORT=16,COMDAT\"", ")", ";", "som_one_only_data_section", "=", "get_unnamed_section", "(", "SECTION_WRITE", ",", "som_output_comdat_data_section_asm_op", ",", "\"\\t.SPACE $PRIVATE$\\n\"", "\"\\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,\"", "\"ACCESS=31,SORT=24,COMDAT\"", ")", ";", "if", "(", "flag_tm", ")", "som_tm_clone_table_section", "=", "get_unnamed_section", "(", "0", ",", "output_section_asm_op", ",", "\"\\t.SPACE $PRIVATE$\\n\\t.SUBSPA $TM_CLONE_TABLE$\"", ")", ";", "readonly_data_section", "=", "flag_pic", "?", "data_section", ":", "som_readonly_data_section", ";", "exception_section", "=", "data_section", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_INITIALIZE_SECTIONS" ]

[ "pa", "0", "0", "\"\\t.SPACE $TEXT$\\n\\t.SUBSPA $LIT$\"", "0", "\"\\t.SPACE $TEXT$\\n\"", "\"\\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,\"", "\"ACCESS=0x2c,SORT=16,COMDAT\"", "\"\\t.SPACE $PRIVATE$\\n\"", "\"\\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,\"", "\"ACCESS=31,SORT=24,COMDAT\"", "0", "\"\\t.SPACE $PRIVATE$\\n\\t.SUBSPA $TM_CLONE_TABLE$\"" ]

[]

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

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

[ "P2", "P2" ]

[]

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

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

[ "Alpha", "Alpha" ]

[]

[ "<s>", "void", "AMDGPUDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "const", "AMDGPUTargetLowering", "&", "Lowering", "=", "(", "(", "const", "AMDGPUTargetLowering", "&", ")", "TLI", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineSDNode", "*", "Node", "=", "dyn_cast", "<", "MachineSDNode", ">", "(", "I", ")", ";", "if", "(", "!", "Node", ")", "continue", ";", "SDNode", "*", "ResNode", "=", "Lowering", ".", "PostISelFolding", "(", "Node", ",", "*", "CurDAG", ")", ";", "if", "(", "ResNode", "!=", "Node", ")", "ReplaceUses", "(", "Node", ",", "ResNode", ")", ";", "}", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "R600" ]

[]

[ "<s>", "bool", "Mips16RegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "ix86_function_specific_post_stream_in", "(", "struct", "cl_target_option", "*", "ptr", ")", "{", "if", "(", "flag_pic", ")", "switch", "(", "ptr", "->", "x_ix86_cmodel", ")", "{", "case", "CM_SMALL", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_SMALL_PIC", ";", "break", ";", "case", "CM_MEDIUM", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_MEDIUM_PIC", ";", "break", ";", "case", "CM_LARGE", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_LARGE_PIC", ";", "break", ";", "case", "CM_KERNEL", ":", "error", "(", "\"code model %s does not support PIC mode\"", ",", "\"kernel\"", ")", ";", "break", ";", "default", ":", "break", ";", "}", "else", "switch", "(", "ptr", "->", "x_ix86_cmodel", ")", "{", "case", "CM_SMALL_PIC", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_SMALL", ";", "break", ";", "case", "CM_MEDIUM_PIC", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_MEDIUM", ";", "break", ";", "case", "CM_LARGE_PIC", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_LARGE", ";", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "Adjust", "target", "options", "after", "streaming", "them", "in", ".", "This", "is", "mainly", "about", "reconciling", "them", "with", "global", "options", "." ]

[ "i386", "\"code model %s does not support PIC mode\"", "\"kernel\"" ]

[]

[ "<s>", "bool", "MipsExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "if", "(", "Modified", ")", "MF", ".", "RenumberBlocks", "(", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "AArch64TargetMachine", "::", "AArch64TargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "LittleEndian", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "LittleEndian", ")", ",", "InstrInfo", "(", "Subtarget", ")", ",", "DL", "(", "LittleEndian", "?", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", ":", "\"E-m:e-i64:64-i128:128-n32:64-S128\"", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "FrameLowering", "(", "Subtarget", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"e-m:e-i64:64-i128:128-n32:64-S128\"", "\"E-m:e-i64:64-i128:128-n32:64-S128\"" ]

[]

[ "<s>", "bool", "HexagonAsmParser", "::", "isLabel", "(", "AsmToken", "&", "Token", ")", "{", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "AsmToken", "const", "&", "Second", "=", "Lexer", ".", "getTok", "(", ")", ";", "AsmToken", "Third", "=", "Lexer", ".", "peekTok", "(", ")", ";", "StringRef", "String", "=", "Token", ".", "getString", "(", ")", ";", "if", "(", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "LCurly", ")", "||", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "RCurly", ")", ")", "return", "false", ";", "if", "(", "!", "Token", ".", "is", "(", "AsmToken", "::", "TokenKind", "::", "Identifier", ")", ")", "return", "true", ";", "if", "(", "!", "matchRegister", "(", "String", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "(", "void", ")", "Second", ";", "assert", "(", "Second", ".", "is", "(", "AsmToken", "::", "Colon", ")", ")", ";", "StringRef", "Raw", "(", "String", ".", "data", "(", ")", ",", "Third", ".", "getString", "(", ")", ".", "data", "(", ")", "-", "String", ".", "data", "(", ")", "+", "Third", ".", "getString", "(", ")", ".", "size", "(", ")", ")", ";", "std", "::", "string", "Collapsed", "=", "Raw", ";", "Collapsed", ".", "erase", "(", "std", "::", "remove_if", "(", "Collapsed", ".", "begin", "(", ")", ",", "Collapsed", ".", "end", "(", ")", ",", "isspace", ")", ",", "Collapsed", ".", "end", "(", ")", ")", ";", "StringRef", "Whole", "=", "Collapsed", ";", "std", "::", "pair", "<", "StringRef", ",", "StringRef", ">", "DotSplit", "=", "Whole", ".", "split", "(", "'.'", ")", ";", "if", "(", "!", "matchRegister", "(", "DotSplit", ".", "first", ".", "lower", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "MachineInstr", "represents", "a", "label", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "HCE", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "getPassName", "(", ")", "<<", "\": skipping \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" due to exception handling\\n\"", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ")", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AssignmentMap", "IMap", ";", "collect", "(", "MF", ")", ";", "llvm", "::", "sort", "(", "Extenders", ",", "[", "this", "]", "(", "const", "ExtDesc", "&", "A", ",", "const", "ExtDesc", "&", "B", ")", "{", "ExtValue", "VA", "(", "A", ")", ",", "VB", "(", "B", ")", ";", "if", "(", "VA", "!=", "VB", ")", "return", "VA", "<", "VB", ";", "const", "MachineInstr", "*", "MA", "=", "A", ".", "UseMI", ";", "const", "MachineInstr", "*", "MB", "=", "B", ".", "UseMI", ";", "if", "(", "MA", "==", "MB", ")", "{", "return", "A", ".", "OpNum", "<", "B", ".", "OpNum", ";", "}", "const", "MachineBasicBlock", "*", "BA", "=", "MA", "->", "getParent", "(", ")", ";", "const", "MachineBasicBlock", "*", "BB", "=", "MB", "->", "getParent", "(", ")", ";", "assert", "(", "BA", "->", "getNumber", "(", ")", "!=", "-", "1", "&&", "BB", "->", "getNumber", "(", ")", "!=", "-", "1", ")", ";", "if", "(", "BA", "!=", "BB", ")", "return", "BA", "->", "getNumber", "(", ")", "<", "BB", "->", "getNumber", "(", ")", ";", "return", "MDT", "->", "dominates", "(", "MA", ",", "MB", ")", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Collected \"", "<<", "Extenders", ".", "size", "(", ")", "<<", "\" extenders\\n\"", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Extenders", ".", "size", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "unsigned", "B", "=", "I", ";", "const", "ExtRoot", "&", "T", "=", "Extenders", "[", "B", "]", ".", "getOp", "(", ")", ";", "while", "(", "I", "!=", "E", "&&", "ExtRoot", "(", "Extenders", "[", "I", "]", ".", "getOp", "(", ")", ")", "==", "T", ")", "++", "I", ";", "IMap", ".", "clear", "(", ")", ";", "assignInits", "(", "T", ",", "B", ",", "I", ",", "IMap", ")", ";", "Changed", "|=", "replaceExtenders", "(", "IMap", ")", ";", "}", "LLVM_DEBUG", "(", "{", "if", "(", "Changed", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "'\\n'", ",", "nullptr", ")", ";", "else", "dbgs", "(", ")", "<<", "\"No changes\\n\"", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "\": skipping \"", "\" due to exception handling\\n\"", "\"Before \"", "Hexagon", "Hexagon", "1", "1", "\"Collected \"", "\" extenders\\n\"", "0", "\"After \"", "\"No changes\\n\"" ]

[]

[ "<s>", "static", "tree", "gcn_lockless_update", "(", "location_t", "loc", ",", "gimple_stmt_iterator", "*", "gsi", ",", "tree", "ptr", ",", "tree", "var", ",", "tree_code", "op", ")", "{", "unsigned", "fn", "=", "GCN_BUILTIN_CMP_SWAP", ";", "tree_code", "code", "=", "NOP_EXPR", ";", "tree", "arg_type", "=", "unsigned_type_node", ";", "tree", "var_type", "=", "TREE_TYPE", "(", "var", ")", ";", "if", "(", "TREE_CODE", "(", "var_type", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "var_type", ")", "==", "REAL_TYPE", ")", "code", "=", "VIEW_CONVERT_EXPR", ";", "if", "(", "TYPE_SIZE", "(", "var_type", ")", "==", "TYPE_SIZE", "(", "long_long_unsigned_type_node", ")", ")", "{", "arg_type", "=", "long_long_unsigned_type_node", ";", "fn", "=", "GCN_BUILTIN_CMP_SWAPLL", ";", "}", "tree", "swap_fn", "=", "gcn_builtin_decl", "(", "fn", ",", "true", ")", ";", "gimple_seq", "init_seq", "=", "NULL", ";", "tree", "init_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "tree", "init_expr", "=", "omp_reduction_init_op", "(", "loc", ",", "op", ",", "var_type", ")", ";", "init_expr", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "init_expr", ")", ";", "gimplify_assign", "(", "init_var", ",", "init_expr", ",", "&", "init_seq", ")", ";", "gimple", "*", "init_end", "=", "gimple_seq_last", "(", "init_seq", ")", ";", "gsi_insert_seq_before", "(", "gsi", ",", "init_seq", ",", "GSI_SAME_STMT", ")", ";", "basic_block", "pre_bb", "=", "gsi_bb", "(", "*", "gsi", ")", ";", "edge", "pre_edge", "=", "split_block", "(", "pre_bb", ",", "init_end", ")", ";", "basic_block", "loop_bb", "=", "pre_edge", "->", "dest", ";", "pre_bb", "=", "pre_edge", "->", "src", ";", "*", "gsi", "=", "gsi_for_stmt", "(", "gsi_stmt", "(", "*", "gsi", ")", ")", ";", "tree", "expect_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "tree", "actual_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "tree", "write_var", "=", "make_ssa_name", "(", "arg_type", ")", ";", "gimple_seq", "red_seq", "=", "NULL", ";", "tree", "write_expr", "=", "fold_build1", "(", "code", ",", "var_type", ",", "expect_var", ")", ";", "write_expr", "=", "fold_build2", "(", "op", ",", "var_type", ",", "write_expr", ",", "var", ")", ";", "write_expr", "=", "fold_build1", "(", "code", ",", "arg_type", ",", "write_expr", ")", ";", "gimplify_assign", "(", "write_var", ",", "write_expr", ",", "&", "red_seq", ")", ";", "gsi_insert_seq_before", "(", "gsi", ",", "red_seq", ",", "GSI_SAME_STMT", ")", ";", "gimple_seq", "latch_seq", "=", "NULL", ";", "tree", "swap_expr", "=", "build_call_expr_loc", "(", "loc", ",", "swap_fn", ",", "3", ",", "ptr", ",", "expect_var", ",", "write_var", ")", ";", "gimplify_assign", "(", "actual_var", ",", "swap_expr", ",", "&", "latch_seq", ")", ";", "gcond", "*", "cond", "=", "gimple_build_cond", "(", "EQ_EXPR", ",", "actual_var", ",", "expect_var", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "gimple_seq_add_stmt", "(", "&", "latch_seq", ",", "cond", ")", ";", "gimple", "*", "latch_end", "=", "gimple_seq_last", "(", "latch_seq", ")", ";", "gsi_insert_seq_before", "(", "gsi", ",", "latch_seq", ",", "GSI_SAME_STMT", ")", ";", "edge", "post_edge", "=", "split_block", "(", "loop_bb", ",", "latch_end", ")", ";", "basic_block", "post_bb", "=", "post_edge", "->", "dest", ";", "loop_bb", "=", "post_edge", "->", "src", ";", "*", "gsi", "=", "gsi_for_stmt", "(", "gsi_stmt", "(", "*", "gsi", ")", ")", ";", "post_edge", "->", "flags", "^=", "EDGE_TRUE_VALUE", "|", "EDGE_FALLTHRU", ";", "edge", "loop_edge", "=", "make_edge", "(", "loop_bb", ",", "loop_bb", ",", "EDGE_FALSE_VALUE", ")", ";", "set_immediate_dominator", "(", "CDI_DOMINATORS", ",", "loop_bb", ",", "pre_bb", ")", ";", "set_immediate_dominator", "(", "CDI_DOMINATORS", ",", "post_bb", ",", "loop_bb", ")", ";", "gphi", "*", "phi", "=", "create_phi_node", "(", "expect_var", ",", "loop_bb", ")", ";", "add_phi_arg", "(", "phi", ",", "init_var", ",", "pre_edge", ",", "loc", ")", ";", "add_phi_arg", "(", "phi", ",", "actual_var", ",", "loop_edge", ",", "loc", ")", ";", "loop", "*", "loop", "=", "alloc_loop", "(", ")", ";", "loop", "->", "header", "=", "loop_bb", ";", "loop", "->", "latch", "=", "loop_bb", ";", "add_loop", "(", "loop", ",", "loop_bb", "->", "loop_father", ")", ";", "return", "fold_build1", "(", "code", ",", "var_type", ",", "write_var", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "gcn_reduction_update", ".", "Insert", "code", "to", "locklessly", "update", "*", "PTR", "with", "*", "PTR", "OP", "VAR", "just", "before", "GSI", ".", "We", "use", "a", "lockless", "scheme", "for", "nearly", "all", "case", ",", "which", "looks", "like", ":", "actual", "=", "initval", "(", "OP", ")", ";", "do", "{", "guess", "=", "actual", ";", "write", "=", "guess", "OP", "myval", ";", "actual", "=", "cmp", "&", "swap", "(", "ptr", ",", "guess", ",", "write", ")", "}", "while", "(", "actual", "bit-different-to", "guess", ")", ";", "return", "write", ";", "This", "relies", "on", "a", "cmp", "&", "swap", "instruction", ",", "which", "is", "available", "for", "32-", "and", "64-bit", "types", ".", "Larger", "types", "must", "use", "a", "locking", "scheme", "." ]

[ "gcn", "3" ]

[]

[ "<s>", "const", "MachineInstr", "*", "HexagonHardwareLoops", "::", "getCanonicalInductionVariable", "(", "MachineLoop", "*", "L", ")", "const", "{", "MachineBasicBlock", "*", "TopMBB", "=", "L", "->", "getTopBlock", "(", ")", ";", "MachineBasicBlock", "::", "pred_iterator", "PI", "=", "TopMBB", "->", "pred_begin", "(", ")", ";", "assert", "(", "PI", "!=", "TopMBB", "->", "pred_end", "(", ")", "&&", "\"Loop must have more than one incoming edge!\"", ")", ";", "MachineBasicBlock", "*", "Backedge", "=", "*", "PI", "++", ";", "if", "(", "PI", "==", "TopMBB", "->", "pred_end", "(", ")", ")", "return", "0", ";", "MachineBasicBlock", "*", "Incoming", "=", "*", "PI", "++", ";", "if", "(", "PI", "!=", "TopMBB", "->", "pred_end", "(", ")", ")", "return", "0", ";", "if", "(", "L", "->", "contains", "(", "Incoming", ")", ")", "{", "if", "(", "L", "->", "contains", "(", "Backedge", ")", ")", "return", "0", ";", "std", "::", "swap", "(", "Incoming", ",", "Backedge", ")", ";", "}", "else", "if", "(", "!", "L", "->", "contains", "(", "Backedge", ")", ")", "return", "0", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "TopMBB", "->", "begin", "(", ")", ",", "E", "=", "TopMBB", "->", "end", "(", ")", ";", "I", "!=", "E", "&&", "I", "->", "isPHI", "(", ")", ";", "++", "I", ")", "{", "const", "MachineInstr", "*", "MPhi", "=", "&", "*", "I", ";", "unsigned", "DefReg", "=", "MPhi", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "for", "(", "unsigned", "i", "=", "1", ";", "i", "!=", "MPhi", "->", "getNumOperands", "(", ")", ";", "i", "+=", "2", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MPhi", "->", "getOperand", "(", "i", "+", "1", ")", ".", "getMBB", "(", ")", ";", "if", "(", "L", "->", "contains", "(", "MBB", ")", ")", "{", "const", "MachineInstr", "*", "DI", "=", "MRI", "->", "getVRegDef", "(", "MPhi", "->", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "isInductionOperation", "(", "DI", ",", "DefReg", ")", ")", "{", "return", "MPhi", ";", "}", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Check", "to", "see", "if", "the", "loop", "has", "a", "canonical", "induction", "variable", ":", "an", "integer", "recurrence", "that", "starts", "at", "0", "and", "increments", "by", "one", "each", "time", "through", "the", "loop", "." ]

[ "Hexagon", "Hexagon", "\"Loop must have more than one incoming edge!\"", "0", "0", "0", "0", "0", "1", "2", "1", "0" ]

[]

[ "<s>", "void", "AMDGPUInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "OS", ".", "flush", "(", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "MBlazeOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "Register", ":", "OS", "<<", "\"<register R\"", ";", "OS", "<<", "getMBlazeRegisterNumbering", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Memory", ":", "{", "OS", "<<", "\"<memory R\"", ";", "OS", "<<", "getMBlazeRegisterNumbering", "(", "getMemBase", "(", ")", ")", ";", "OS", "<<", "\", \"", ";", "unsigned", "RegOff", "=", "getMemOffReg", "(", ")", ";", "if", "(", "RegOff", ")", "OS", "<<", "\"R\"", "<<", "getMBlazeRegisterNumbering", "(", "RegOff", ")", ";", "else", "OS", "<<", "getMemOff", "(", ")", ";", "OS", "<<", "\">\"", ";", "}", "break", ";", "case", "Fsl", ":", "getFslImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "\"<register R\"", "MBlaze", "\">\"", "\"'\"", "\"'\"", "\"<memory R\"", "MBlaze", "\", \"", "\"R\"", "MBlaze", "\">\"" ]

[]

[ "<s>", "bool", "TPCAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "AsmToken", "SectionNameToken", "=", "DirectiveID", ".", "getString", "(", ")", ".", "equals", "(", "\".section\"", ")", "?", "getTok", "(", ")", ":", "DirectiveID", ";", "const", "char", "*", "MultipleDefErrorMessage", "=", "\"Multi definition {0} is denied\"", ";", "bool", "ParseResult", "=", "true", ";", "if", "(", "SectionNameToken", ".", "getString", "(", ")", ".", "equals_lower", "(", "BinaryTPCMetadataSectionName", ")", ")", "{", "if", "(", "TPCHeader", ")", "{", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "formatv", "(", "MultipleDefErrorMessage", ",", "StringTPCMetadataSectionName", ")", ",", "DirectiveID", ".", "getLocRange", "(", ")", ")", ";", "return", "false", ";", "}", "Lexer", ".", "Lex", "(", ")", ";", "ParseResult", "=", "parseTPCMetadata", "(", ")", ";", "}", "else", "if", "(", "SectionNameToken", ".", "getString", "(", ")", ".", "equals_lower", "(", "IndexMapSectionName", ")", ")", "{", "if", "(", "IndexMap", ")", "{", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "formatv", "(", "MultipleDefErrorMessage", ",", "IndexMapSectionName", ")", ",", "DirectiveID", ".", "getLocRange", "(", ")", ")", ";", "return", "false", ";", "}", "Lexer", ".", "Lex", "(", ")", ";", "ParseResult", "=", "parseIndexMap", "(", ")", ";", "}", "if", "(", "!", "ParseResult", ")", "Error", "(", "SectionNameToken", ".", "getLoc", "(", ")", ",", "formatv", "(", "\"Error occured during parse section {0}\"", ",", "SectionNameToken", ".", "getString", "(", ")", ")", ",", "SectionNameToken", ".", "getLocRange", "(", ")", ")", ";", "return", "ParseResult", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "\".section\"", "\"Multi definition {0} is denied\"", "TPC", "TPC", "TPC", "TPC", "\"Error occured during parse section {0}\"" ]

[]

[ "<s>", "bool", "scalar_chain", "::", "analyze_register_chain", "(", "bitmap", "candidates", ",", "df_ref", "ref", ",", "bitmap", "disallowed", ")", "{", "df_link", "*", "chain", ";", "bool", "mark_def", "=", "false", ";", "gcc_checking_assert", "(", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", ";", "for", "(", "chain", "=", "DF_REF_CHAIN", "(", "ref", ")", ";", "chain", ";", "chain", "=", "chain", "->", "next", ")", "{", "unsigned", "uid", "=", "DF_REF_INSN_UID", "(", "chain", "->", "ref", ")", ";", "if", "(", "!", "NONDEBUG_INSN_P", "(", "DF_REF_INSN", "(", "chain", "->", "ref", ")", ")", ")", "continue", ";", "if", "(", "--", "max_visits", "==", "0", ")", "return", "false", ";", "if", "(", "!", "DF_REF_REG_MEM_P", "(", "chain", "->", "ref", ")", ")", "{", "if", "(", "bitmap_bit_p", "(", "insns", ",", "uid", ")", ")", "continue", ";", "if", "(", "bitmap_bit_p", "(", "candidates", ",", "uid", ")", ")", "{", "add_to_queue", "(", "uid", ")", ";", "continue", ";", "}", "if", "(", "bitmap_bit_p", "(", "disallowed", ",", "uid", ")", ")", "return", "false", ";", "}", "if", "(", "DF_REF_REG_DEF_P", "(", "chain", "->", "ref", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" r%d def in insn %d isn't convertible\\n\"", ",", "DF_REF_REGNO", "(", "chain", "->", "ref", ")", ",", "uid", ")", ";", "mark_dual_mode_def", "(", "chain", "->", "ref", ")", ";", "}", "else", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" r%d use in insn %d isn't convertible\\n\"", ",", "DF_REF_REGNO", "(", "chain", "->", "ref", ")", ",", "uid", ")", ";", "mark_def", "=", "true", ";", "}", "}", "if", "(", "mark_def", ")", "mark_dual_mode_def", "(", "ref", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Check", "REF", "'s", "chain", "to", "add", "new", "insns", "into", "a", "queue", "and", "find", "registers", "requiring", "conversion", ".", "Return", "true", "if", "OK", ",", "false", "if", "the", "analysis", "was", "aborted", "." ]

[ "i386", "0", "\" r%d def in insn %d isn't convertible\\n\"", "\" r%d use in insn %d isn't convertible\\n\"" ]

[]

[ "<s>", "static", "void", "rs6000_finish_atomic_subword", "(", "rtx", "narrow", ",", "rtx", "wide", ",", "rtx", "shift", ")", "{", "wide", "=", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "wide", ",", "shift", ",", "wide", ",", "1", ",", "OPTAB_LIB_WIDEN", ")", ";", "emit_move_insn", "(", "narrow", ",", "gen_lowpart", "(", "GET_MODE", "(", "narrow", ")", ",", "wide", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "various", "atomic", "expanders", ".", "For", "sub-word", "operands", ",", "extract", "WIDE", "to", "NARROW", "via", "SHIFT", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "int", "frv_emit_cond_branch", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "test_rtx", ";", "rtx", "label_ref", ";", "rtx", "if_else", ";", "enum", "rtx_code", "test", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "cc_reg", "=", "frv_emit_comparison", "(", "test", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "machine_mode", "cc_mode", "=", "GET_MODE", "(", "cc_reg", ")", ";", "label_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "3", "]", ")", ";", "test_rtx", "=", "gen_rtx_fmt_ee", "(", "test", ",", "cc_mode", ",", "cc_reg", ",", "const0_rtx", ")", ";", "if_else", "=", "gen_rtx_IF_THEN_ELSE", "(", "cc_mode", ",", "test_rtx", ",", "label_ref", ",", "pc_rtx", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "if_else", ")", ")", ";", "return", "TRUE", ";", "}", "</s>" ]

[ "Emit", "code", "for", "a", "conditional", "branch", ".", "The", "comparison", "operands", "were", "previously", "stored", "in", "frv_compare_op0", "and", "frv_compare_op1", ".", "XXX", ":", "I", "originally", "wanted", "to", "add", "a", "clobber", "of", "a", "CCR", "register", "to", "use", "in", "conditional", "execution", ",", "but", "that", "confuses", "the", "rest", "of", "the", "compiler", "." ]

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

[]

[ "<s>", "static", "bool", "nvptx_function_ok_for_sibcall", "(", "tree", ",", "tree", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "For", "ptx", ",", "we", "ca", "n't", "." ]

[ "nvptx" ]

[]

[ "<s>", "const", "char", "*", "MipsAsmPrinter", "::", "getCurrentABIString", "(", ")", "const", "{", "switch", "(", "Subtarget", "->", "getTargetABI", "(", ")", ")", "{", "case", "MipsSubtarget", "::", "O32", ":", "return", "\"abi32\"", ";", "case", "MipsSubtarget", "::", "N32", ":", "return", "\"abiN32\"", ";", "case", "MipsSubtarget", "::", "N64", ":", "return", "\"abi64\"", ";", "case", "MipsSubtarget", "::", "EABI", ":", "return", "\"eabi32\"", ";", "default", ":", "break", ";", "}", "llvm_unreachable", "(", "\"Unknown Mips ABI\"", ")", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Emit", "Set", "directives", "." ]

[ "Mips", "Mips", "Mips", "\"abi32\"", "Mips", "\"abiN32\"", "Mips", "\"abi64\"", "Mips", "\"eabi32\"", "\"Unknown Mips ABI\"" ]

[]

[ "<s>", "static", "bool", "mmix_rtx_costs", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "int", "code", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", "ATTRIBUTE_UNUSED", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "TARGET_RTX_COSTS", "." ]

[ "mmix" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "MOSAsmPrinter", "::", "emitJumpTableInfo", "(", ")", "{", "const", "DataLayout", "&", "DL", "=", "MF", "->", "getDataLayout", "(", ")", ";", "const", "MachineJumpTableInfo", "*", "MJTI", "=", "MF", "->", "getJumpTableInfo", "(", ")", ";", "if", "(", "!", "MJTI", ")", "return", ";", "assert", "(", "MJTI", "->", "getEntryKind", "(", ")", "==", "MachineJumpTableInfo", "::", "EK_BlockAddress", ")", ";", "const", "std", "::", "vector", "<", "MachineJumpTableEntry", ">", "&", "JT", "=", "MJTI", "->", "getJumpTables", "(", ")", ";", "if", "(", "JT", ".", "empty", "(", ")", ")", "return", ";", "const", "Function", "&", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "const", "TargetLoweringObjectFile", "&", "TLOF", "=", "getObjFileLowering", "(", ")", ";", "bool", "JTInDiffSection", "=", "!", "TLOF", ".", "shouldPutJumpTableInFunctionSection", "(", "false", ",", "F", ")", ";", "if", "(", "JTInDiffSection", ")", "{", "MCSection", "*", "ReadOnlySection", "=", "TLOF", ".", "getSectionForJumpTable", "(", "F", ",", "TM", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ReadOnlySection", ")", ";", "}", "emitAlignment", "(", "Align", "(", "MJTI", "->", "getEntryAlignment", "(", "DL", ")", ")", ")", ";", "if", "(", "!", "JTInDiffSection", ")", "OutStreamer", "->", "emitDataRegion", "(", "MCDR_DataRegionJT32", ")", ";", "for", "(", "const", "auto", "&", "JTI", ":", "enumerate", "(", "JT", ")", ")", "{", "const", "std", "::", "vector", "<", "MachineBasicBlock", "*", ">", "&", "JTBBs", "=", "JTI", ".", "value", "(", ")", ".", "MBBs", ";", "if", "(", "JTBBs", ".", "empty", "(", ")", ")", "continue", ";", "MCSymbol", "*", "JTISymbol", "=", "GetJTISymbol", "(", "JTI", ".", "index", "(", ")", ")", ";", "OutStreamer", "->", "emitLabel", "(", "JTISymbol", ")", ";", "for", "(", "const", "MachineBasicBlock", "*", "JTBB", ":", "JTBBs", ")", "{", "OutStreamer", "->", "emitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "JTBB", "->", "getSymbol", "(", ")", ",", "MCSymbolRefExpr", "::", "VK_MOS_ADDR16_LO", ",", "OutContext", ")", ",", "1", ")", ";", "}", "for", "(", "const", "MachineBasicBlock", "*", "JTBB", ":", "JTBBs", ")", "{", "OutStreamer", "->", "emitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "JTBB", "->", "getSymbol", "(", ")", ",", "MCSymbolRefExpr", "::", "VK_MOS_ADDR16_HI", ",", "OutContext", ")", ",", "1", ")", ";", "}", "}", "if", "(", "!", "JTInDiffSection", ")", "OutStreamer", "->", "emitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "}", "</s>" ]

[ "Print", "assembly", "representations", "of", "the", "jump", "tables", "used", "by", "the", "current", "function", "to", "the", "current", "output", "stream", "." ]

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

[]

[ "<s>", "void", "arm_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "tree", "fntype", ",", "rtx", "libname", ",", "tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "fntype", ")", "pcum", "->", "pcs_variant", "=", "arm_get_pcs_model", "(", "fntype", ",", "fndecl", ")", ";", "else", "pcum", "->", "pcs_variant", "=", "arm_pcs_default", ";", "if", "(", "pcum", "->", "pcs_variant", "<=", "ARM_PCS_AAPCS_LOCAL", ")", "{", "if", "(", "arm_libcall_uses_aapcs_base", "(", "libname", ")", ")", "pcum", "->", "pcs_variant", "=", "ARM_PCS_AAPCS", ";", "pcum", "->", "aapcs_ncrn", "=", "pcum", "->", "aapcs_next_ncrn", "=", "0", ";", "pcum", "->", "aapcs_reg", "=", "NULL_RTX", ";", "pcum", "->", "aapcs_partial", "=", "0", ";", "pcum", "->", "aapcs_arg_processed", "=", "false", ";", "pcum", "->", "aapcs_cprc_slot", "=", "-", "1", ";", "pcum", "->", "can_split", "=", "true", ";", "if", "(", "pcum", "->", "pcs_variant", "!=", "ARM_PCS_AAPCS", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARM_NUM_COPROC_SLOTS", ";", "i", "++", ")", "{", "pcum", "->", "aapcs_cprc_failed", "[", "i", "]", "=", "false", ";", "aapcs_cp_arg_layout", "[", "i", "]", ".", "cum_init", "(", "pcum", ",", "fntype", ",", "libname", ",", "fndecl", ")", ";", "}", "}", "return", ";", "}", "pcum", "->", "nregs", "=", "0", ";", "pcum", "->", "iwmmxt_nregs", "=", "0", ";", "pcum", "->", "can_split", "=", "true", ";", "pcum", "->", "named_count", "=", "0", ";", "pcum", "->", "nargs", "=", "0", ";", "if", "(", "TARGET_REALLY_IWMMXT", "&&", "fntype", ")", "{", "tree", "fn_arg", ";", "for", "(", "fn_arg", "=", "TYPE_ARG_TYPES", "(", "fntype", ")", ";", "fn_arg", ";", "fn_arg", "=", "TREE_CHAIN", "(", "fn_arg", ")", ")", "pcum", "->", "named_count", "+=", "1", ";", "if", "(", "!", "pcum", "->", "named_count", ")", "pcum", "->", "named_count", "=", "INT_MAX", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "ARMTTIImpl", "::", "getIntImmCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "Candidate", "(", "const", "SUnit", "*", "SU_", ",", "int", "Priority_", "=", "0", ")", ":", "SU", "(", "SU_", ")", ",", "Priority", "(", "Priority_", ")", "{", "}", "</s>" ]

[ "Describes", "the", "region", "of", "code", "." ]

[ "AMDGPU", "0" ]

[]

[ "<s>", "static", "int", "round_frame_size", "(", "int", "size", ")", "{", "return", "(", "(", "size", "+", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", "&", "-", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "Round", "up", "frame", "size", "SIZE", "." ]

[ "tilegx", "1" ]

[]

[ "<s>", "rtx", "ix86_function_value", "(", "tree", "valtype", ",", "tree", "fntype_or_decl", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "natmode", "=", "type_natural_mode", "(", "valtype", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "rtx", "ret", "=", "construct_container", "(", "natmode", ",", "TYPE_MODE", "(", "valtype", ")", ",", "valtype", ",", "1", ",", "REGPARM_MAX", ",", "SSE_REGPARM_MAX", ",", "x86_64_int_return_registers", ",", "0", ")", ";", "if", "(", "!", "ret", ")", "ret", "=", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "0", ")", ";", "return", "ret", ";", "}", "else", "{", "tree", "fn", "=", "NULL_TREE", ",", "fntype", ";", "if", "(", "fntype_or_decl", "&&", "DECL_P", "(", "fntype_or_decl", ")", ")", "fn", "=", "fntype_or_decl", ";", "fntype", "=", "fn", "?", "TREE_TYPE", "(", "fn", ")", ":", "fntype_or_decl", ";", "return", "gen_rtx_REG", "(", "TYPE_MODE", "(", "valtype", ")", ",", "ix86_value_regno", "(", "natmode", ",", "fn", ",", "fntype", ")", ")", ";", "}", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", ".", "VALTYPE", "is", "the", "data", "type", "of", "the", "value", "(", "as", "a", "tree", ")", ".", "If", "the", "precise", "function", "being", "called", "is", "known", ",", "FUNC", "is", "its", "FUNCTION_DECL", ";", "otherwise", ",", "FUNC", "is", "0", "." ]

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

[]

[ "<s>", "static", "rtx", "or1k_delegitimize_address", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "{", "if", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFF", ")", "return", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", "&&", "XEXP", "(", "addr", ",", "0", ")", "==", "pic_offset_table_rtx", ")", "{", "rtx", "inner", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "inner", ")", "==", "UNSPEC", "&&", "XINT", "(", "inner", ",", "1", ")", "==", "UNSPEC_GOT", ")", "return", "XVECEXP", "(", "inner", ",", "0", ",", "0", ")", ";", "}", "}", "return", "delegitimize_mem_from_attrs", "(", "x", ")", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_DELEGITIMIZE_ADDRESS", ".", "In", "the", "name", "of", "slightly", "smaller", "debug", "output", ",", "and", "to", "cater", "to", "general", "assembler", "lossage", ",", "recognize", "PIC+GOTOFF", "and", "turn", "it", "back", "into", "a", "direct", "symbol", "reference", "." ]

[ "or1k", "1", "0", "0", "0", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "AArch64TargetLowering", "::", "findRepresentativeClass", "(", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "nullptr", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "v4i64", ":", "RRC", "=", "&", "AArch64", "::", "QPairRegClass", ";", "Cost", "=", "2", ";", "break", ";", "case", "MVT", "::", "v8i64", ":", "RRC", "=", "&", "AArch64", "::", "QQuadRegClass", ";", "Cost", "=", "4", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "AArch64", "AArch64", "1", "MVT::v4i64", "AArch64::QPairRegClass", "2", "MVT::v8i64", "AArch64::QQuadRegClass", "4" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "if", "(", "MergeInit", ")", "AU", ".", "addRequired", "<", "AAResultsWrapperPass", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "shouldInsertFencesForAtomic", "(", "const", "Instruction", "*", "I", ")", "const", "override", "{", "return", "isa", "<", "LoadInst", ">", "(", "I", ")", "||", "isa", "<", "StoreInst", ">", "(", "I", ")", ";", "}", "</s>" ]

[ "Helper", "functions", "for", "atomic", "operations", "." ]

[ "RISCV" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "XZR", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "WSP", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "WZR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "{", "Reserved", ".", "set", "(", "AArch64", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "W29", ")", ";", "}", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isX18Reserved", "(", ")", ")", "{", "Reserved", ".", "set", "(", "AArch64", "::", "X18", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "W18", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "AArch64", "::", "X19", ")", ";", "Reserved", ".", "set", "(", "AArch64", "::", "W19", ")", ";", "}", "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", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64::SP", "AArch64::XZR", "AArch64::WSP", "AArch64::WZR", "AArch64::FP", "AArch64::W29", "AArch64", "AArch64::X18", "AArch64::W18", "AArch64::X19", "AArch64::W19" ]

[]

[ "<s>", "static", "bool", "ix86_expand_sse_fp_minmax", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "if_true", ",", "rtx", "if_false", ")", "{", "machine_mode", "mode", ";", "bool", "is_min", ";", "rtx", "tmp", ";", "if", "(", "code", "==", "LT", ")", ";", "else", "if", "(", "code", "==", "UNGE", ")", "std", "::", "swap", "(", "if_true", ",", "if_false", ")", ";", "else", "return", "false", ";", "if", "(", "rtx_equal_p", "(", "cmp_op0", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op1", ",", "if_false", ")", ")", "is_min", "=", "true", ";", "else", "if", "(", "rtx_equal_p", "(", "cmp_op1", ",", "if_true", ")", "&&", "rtx_equal_p", "(", "cmp_op0", ",", "if_false", ")", ")", "is_min", "=", "false", ";", "else", "return", "false", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "flag_finite_math_only", "||", "flag_signed_zeros", ")", "{", "int", "u", "=", "is_min", "?", "UNSPEC_IEEE_MIN", ":", "UNSPEC_IEEE_MAX", ";", "rtvec", "v", ";", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "v", "=", "gen_rtvec", "(", "2", ",", "if_true", ",", "if_false", ")", ";", "tmp", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "v", ",", "u", ")", ";", "}", "else", "{", "code", "=", "is_min", "?", "SMIN", ":", "SMAX", ";", "if", "(", "MEM_P", "(", "if_true", ")", "&&", "MEM_P", "(", "if_false", ")", ")", "if_true", "=", "force_reg", "(", "mode", ",", "if_true", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "if_true", ",", "if_false", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "tmp", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Detect", "conditional", "moves", "that", "exactly", "match", "min/max", "operational", "semantics", ".", "Note", "that", "this", "is", "IEEE", "safe", ",", "as", "long", "as", "we", "do", "n't", "interchange", "the", "operands", ".", "Returns", "FALSE", "if", "this", "conditional", "move", "does", "n't", "match", "a", "MIN/MAX", ",", "and", "TRUE", "if", "the", "operation", "is", "successful", "and", "instructions", "are", "emitted", "." ]

[ "i386", "2" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", "->", "isSplitCSR", "(", ")", "?", "CSR_AArch64_CXX_TLS_Darwin_PE_SaveList", ":", "CSR_AArch64_CXX_TLS_Darwin_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "else", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "new", "X86ExecutionDepsFix", "(", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupBWInsts", "(", ")", ")", ";", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "addPass", "(", "createX86EvexToVexInsts", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

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

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

[ "WebAssembly", "\"WebAssembly late peephole optimizer\"" ]

[]

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

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "bool", "SystemZAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "*", "ExtraCode", "==", "'n'", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "OS", "<<", "-", "int64_t", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "getImm", "(", ")", ")", ";", "}", "else", "{", "SystemZMCInstLower", "Lower", "(", "MF", "->", "getContext", "(", ")", ",", "*", "this", ")", ";", "MCOperand", "MO", "(", "Lower", ".", "lowerOperand", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ")", ")", ";", "SystemZInstPrinter", "::", "printOperand", "(", "MO", ",", "OS", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "arm_load_pic_register", "(", "unsigned", "long", "saved_regs", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "l1", ",", "labelno", ",", "pic_tmp", ",", "pic_rtx", ",", "pic_reg", ";", "if", "(", "crtl", "->", "uses_pic_offset_table", "==", "0", "||", "TARGET_SINGLE_PIC_BASE", ")", "return", ";", "gcc_assert", "(", "flag_pic", ")", ";", "pic_reg", "=", "cfun", "->", "machine", "->", "pic_reg", ";", "if", "(", "TARGET_VXWORKS_RTP", ")", "{", "pic_rtx", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "VXWORKS_GOTT_BASE", ")", ";", "pic_rtx", "=", "gen_rtx_CONST", "(", "Pmode", ",", "pic_rtx", ")", ";", "emit_insn", "(", "gen_pic_load_addr_32bit", "(", "pic_reg", ",", "pic_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "Pmode", ",", "pic_reg", ",", "gen_rtx_MEM", "(", "Pmode", ",", "pic_reg", ")", ")", ")", ";", "pic_tmp", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "VXWORKS_GOTT_INDEX", ")", ";", "emit_insn", "(", "gen_pic_offset_arm", "(", "pic_reg", ",", "pic_reg", ",", "pic_tmp", ")", ")", ";", "}", "else", "{", "labelno", "=", "GEN_INT", "(", "pic_labelno", "++", ")", ";", "l1", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "labelno", ")", ",", "UNSPEC_PIC_LABEL", ")", ";", "l1", "=", "gen_rtx_CONST", "(", "VOIDmode", ",", "l1", ")", ";", "pic_rtx", "=", "plus_constant", "(", "Pmode", ",", "l1", ",", "TARGET_ARM", "?", "8", ":", "4", ")", ";", "pic_rtx", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "pic_rtx", ")", ",", "UNSPEC_GOTSYM_OFF", ")", ";", "pic_rtx", "=", "gen_rtx_CONST", "(", "Pmode", ",", "pic_rtx", ")", ";", "if", "(", "TARGET_32BIT", ")", "{", "emit_insn", "(", "gen_pic_load_addr_unified", "(", "pic_reg", ",", "pic_rtx", ",", "labelno", ")", ")", ";", "}", "else", "{", "if", "(", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "REGNO", "(", "pic_reg", ")", ">", "LAST_LO_REGNUM", ")", "{", "pic_tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "thumb_find_work_register", "(", "saved_regs", ")", ")", ";", "emit_insn", "(", "gen_pic_load_addr_thumb1", "(", "pic_tmp", ",", "pic_rtx", ")", ")", ";", "emit_insn", "(", "gen_movsi", "(", "pic_offset_table_rtx", ",", "pic_tmp", ")", ")", ";", "emit_insn", "(", "gen_pic_add_dot_plus_four", "(", "pic_reg", ",", "pic_reg", ",", "labelno", ")", ")", ";", "}", "else", "if", "(", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "arm_pic_register", ">", "LAST_LO_REGNUM", "&&", "REGNO", "(", "pic_reg", ")", "<=", "LAST_LO_REGNUM", ")", "{", "emit_insn", "(", "gen_pic_load_addr_unified", "(", "pic_reg", ",", "pic_rtx", ",", "labelno", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "arm_pic_register", ")", ",", "pic_reg", ")", ";", "emit_use", "(", "gen_rtx_REG", "(", "Pmode", ",", "arm_pic_register", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_pic_load_addr_unified", "(", "pic_reg", ",", "pic_rtx", ",", "labelno", ")", ")", ";", "}", "}", "emit_use", "(", "pic_reg", ")", ";", "}", "</s>" ]

[ "Generate", "code", "to", "load", "the", "PIC", "register", ".", "In", "thumb", "mode", "SCRATCH", "is", "a", "low", "register", "." ]

[ "arm", "0", "1", "8", "4", "1" ]

[]

[ "<s>", "int64_t", "mmix_intval", "(", "const_rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "return", "INTVAL", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "return", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", ")", "{", "long", "bits", "[", "2", "]", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "bits", ")", ";", "return", "(", "(", "uint64_t", ")", "(", "unsigned", "long", ")", "bits", "[", "0", "]", "<<", "(", "uint64_t", ")", "32U", ")", "|", "(", "uint64_t", ")", "(", "unsigned", "long", ")", "bits", "[", "1", "]", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "{", "long", "bits", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "bits", ")", ";", "return", "(", "unsigned", "long", ")", "bits", ";", "}", "}", "fatal_insn", "(", "\"MMIX Internal: This is not a constant:\"", ",", "x", ")", ";", "}", "</s>" ]

[ "Return", "the", "bit-value", "for", "a", "const_int", "or", "const_double", "." ]

[ "mmix", "2", "0", "32U", "1", "\"MMIX Internal: This is not a constant:\"" ]

[]

[ "<s>", "static", "void", "sparc_init_builtins", "(", "void", ")", "{", "if", "(", "TARGET_FPU", ")", "sparc_fpu_init_builtins", "(", ")", ";", "if", "(", "TARGET_VIS", ")", "sparc_vis_init_builtins", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_INIT_BUILTINS", "target", "hook", ".", "Create", "builtin", "functions", "for", "special", "SPARC", "instructions", "." ]

[ "sparc" ]

[]

[ "<s>", "void", "Mips16RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "iq2000_count_memory_refs", "(", "rtx", "op", ",", "int", "num", ")", "{", "int", "additional", "=", "0", ";", "int", "n_words", "=", "0", ";", "rtx", "addr", ",", "plus0", ",", "plus1", ";", "enum", "rtx_code", "code0", ",", "code1", ";", "int", "looping", ";", "if", "(", "TARGET_DEBUG_B_MODE", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n========== iq2000_count_memory_refs:\\n\"", ")", ";", "debug_rtx", "(", "op", ")", ";", "}", "addr", "=", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "?", "op", ":", "XEXP", "(", "op", ",", "0", ")", ";", "do", "{", "looping", "=", "FALSE", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "case", "CONST_INT", ":", "case", "LO_SUM", ":", "break", ";", "case", "PLUS", ":", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "code0", "=", "GET_CODE", "(", "plus0", ")", ";", "code1", "=", "GET_CODE", "(", "plus1", ")", ";", "if", "(", "code0", "==", "REG", ")", "{", "additional", "++", ";", "addr", "=", "plus1", ";", "looping", "=", "1", ";", "continue", ";", "}", "if", "(", "code0", "==", "CONST_INT", ")", "{", "addr", "=", "plus1", ";", "looping", "=", "1", ";", "continue", ";", "}", "if", "(", "code1", "==", "REG", ")", "{", "additional", "++", ";", "addr", "=", "plus0", ";", "looping", "=", "1", ";", "continue", ";", "}", "if", "(", "code1", "==", "CONST_INT", ")", "{", "addr", "=", "plus0", ";", "looping", "=", "1", ";", "continue", ";", "}", "if", "(", "code0", "==", "SYMBOL_REF", "||", "code0", "==", "LABEL_REF", "||", "code0", "==", "CONST", ")", "{", "addr", "=", "plus0", ";", "looping", "=", "1", ";", "continue", ";", "}", "if", "(", "code1", "==", "SYMBOL_REF", "||", "code1", "==", "LABEL_REF", "||", "code1", "==", "CONST", ")", "{", "addr", "=", "plus1", ";", "looping", "=", "1", ";", "continue", ";", "}", "break", ";", "case", "LABEL_REF", ":", "n_words", "=", "2", ";", "break", ";", "case", "CONST", ":", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "looping", "=", "1", ";", "continue", ";", "case", "SYMBOL_REF", ":", "n_words", "=", "SYMBOL_REF_FLAG", "(", "addr", ")", "?", "1", ":", "2", ";", "break", ";", "default", ":", "break", ";", "}", "}", "while", "(", "looping", ")", ";", "if", "(", "n_words", "==", "0", ")", "return", ";", "n_words", "+=", "additional", ";", "if", "(", "n_words", ">", "3", ")", "n_words", "=", "3", ";", "num_refs", "[", "n_words", "-", "1", "]", "+=", "num", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "memory", "reference", "takes", "one", "(", "based", "off", "of", "the", "GP", "pointer", ")", ",", "two", "(", "normal", ")", ",", "or", "three", "(", "label", "+", "reg", ")", "instructions", ",", "and", "bump", "the", "appropriate", "counter", "for", "-mstats", "." ]

[ "iq2000", "0", "0", "\"\\n========== iq2000_count_memory_refs:\\n\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "2", "0", "1", "1", "2", "0", "3", "3", "1" ]

[]

[ "<s>", "static", "void", "msp430_print_operand_raw", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "HOST_WIDE_INT", "i", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "break", ";", "case", "CONST_INT", ":", "i", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "TARGET_ASM_HEX", ")", "fprintf", "(", "file", ",", "\"%#\"", "HOST_WIDE_INT_PRINT", "\"x\"", ",", "i", ")", ";", "else", "fprintf", "(", "file", ",", "\"%\"", "HOST_WIDE_INT_PRINT", "\"d\"", ",", "i", ")", ";", "break", ";", "case", "CONST", ":", "case", "PLUS", ":", "case", "MINUS", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "break", ";", "default", ":", "print_rtl", "(", "file", ",", "op", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Common", "code", "for", "msp430_print_operand", "..." ]

[ "msp430", "\"%s\"", "\"%#\"", "\"x\"", "\"%\"", "\"d\"" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "relaxInstruction", "(", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "MCInst", "Res", ";", "unsigned", "RelaxedOpcode", "=", "AMDGPU", "::", "getSOPPWithRelaxation", "(", "Inst", ".", "getOpcode", "(", ")", ")", ";", "Res", ".", "setOpcode", "(", "RelaxedOpcode", ")", ";", "Res", ".", "addOperand", "(", "Inst", ".", "getOperand", "(", "0", ")", ")", ";", "Inst", "=", "std", "::", "move", "(", "Res", ")", ";", "return", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::getSOPPWithRelaxation", "0" ]

[]

[ "<s>", "void", "override_options", "(", "void", ")", "{", "int", "regno", ";", "enum", "machine_mode", "mode", ";", "if", "(", "!", "TARGET_BOOLEANS", "&&", "TARGET_HARD_FLOAT", ")", "error", "(", "\"boolean registers required for the floating-point option\"", ")", ";", "xtensa_char_to_class", "[", "'q'", "]", "=", "SP_REG", ";", "xtensa_char_to_class", "[", "'a'", "]", "=", "GR_REGS", ";", "xtensa_char_to_class", "[", "'b'", "]", "=", "(", "(", "TARGET_BOOLEANS", ")", "?", "BR_REGS", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'f'", "]", "=", "(", "(", "TARGET_HARD_FLOAT", ")", "?", "FP_REGS", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'A'", "]", "=", "(", "(", "TARGET_MAC16", ")", "?", "ACC_REG", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'B'", "]", "=", "(", "(", "TARGET_SEXT", ")", "?", "GR_REGS", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'C'", "]", "=", "(", "(", "TARGET_MUL16", ")", "?", "GR_REGS", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'D'", "]", "=", "(", "(", "TARGET_DENSITY", ")", "?", "GR_REGS", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'d'", "]", "=", "(", "(", "TARGET_DENSITY", ")", "?", "AR_REGS", ":", "NO_REGS", ")", ";", "xtensa_char_to_class", "[", "'W'", "]", "=", "(", "(", "TARGET_CONST16", ")", "?", "GR_REGS", ":", "NO_REGS", ")", ";", "for", "(", "mode", "=", "VOIDmode", ";", "mode", "!=", "MAX_MACHINE_MODE", ";", "mode", "=", "(", "enum", "machine_mode", ")", "(", "(", "int", ")", "mode", "+", "1", ")", ")", "{", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "enum", "mode_class", "class", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "{", "int", "temp", ";", "if", "(", "ACC_REG_P", "(", "regno", ")", ")", "temp", "=", "(", "TARGET_MAC16", "&&", "(", "class", "==", "MODE_INT", ")", "&&", "(", "size", "<=", "UNITS_PER_WORD", ")", ")", ";", "else", "if", "(", "GP_REG_P", "(", "regno", ")", ")", "temp", "=", "(", "(", "regno", "&", "1", ")", "==", "0", "||", "(", "size", "<=", "UNITS_PER_WORD", ")", ")", ";", "else", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "temp", "=", "(", "TARGET_HARD_FLOAT", "&&", "(", "mode", "==", "SFmode", ")", ")", ";", "else", "if", "(", "BR_REG_P", "(", "regno", ")", ")", "temp", "=", "(", "TARGET_BOOLEANS", "&&", "(", "mode", "==", "CCmode", ")", ")", ";", "else", "temp", "=", "FALSE", ";", "xtensa_hard_regno_mode_ok", "[", "(", "int", ")", "mode", "]", "[", "regno", "]", "=", "temp", ";", "}", "}", "init_machine_status", "=", "xtensa_init_machine_status", ";", "if", "(", "flag_pic", "&&", "TARGET_CONST16", ")", "error", "(", "\"-f%s is not supported with CONST16 instructions\"", ",", "(", "flag_pic", ">", "1", "?", "\"PIC\"", ":", "\"pic\"", ")", ")", ";", "else", "if", "(", "XTENSA_ALWAYS_PIC", ")", "{", "if", "(", "TARGET_CONST16", ")", "error", "(", "\"PIC is required but not supported with CONST16 instructions\"", ")", ";", "flag_pic", "=", "1", ";", "}", "if", "(", "flag_pic", ">", "1", ")", "flag_pic", "=", "1", ";", "if", "(", "flag_reorder_blocks_and_partition", ")", "{", "flag_reorder_blocks_and_partition", "=", "0", ";", "flag_reorder_blocks", "=", "1", ";", "}", "}", "</s>" ]

[ "Set", "global", "variables", "as", "needed", "for", "the", "options", "enabled", "." ]

[ "xtensa", "\"boolean registers required for the floating-point option\"", "1", "0", "1", "0", "\"-f%s is not supported with CONST16 instructions\"", "1", "\"PIC\"", "\"pic\"", "\"PIC is required but not supported with CONST16 instructions\"", "1", "1", "1", "0", "1" ]

[]

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

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

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

[]

[ "<s>", "int", "arm_mac_accumulator_is_mul_result", "(", "rtx", "producer", ",", "rtx", "consumer", ")", "{", "rtx", "mul", "=", "PATTERN", "(", "producer", ")", ";", "rtx", "mac", "=", "PATTERN", "(", "consumer", ")", ";", "rtx", "mul_result", ";", "rtx", "mac_op0", ",", "mac_op1", ",", "mac_acc", ";", "if", "(", "GET_CODE", "(", "mul", ")", "==", "COND_EXEC", ")", "mul", "=", "COND_EXEC_CODE", "(", "mul", ")", ";", "if", "(", "GET_CODE", "(", "mac", ")", "==", "COND_EXEC", ")", "mac", "=", "COND_EXEC_CODE", "(", "mac", ")", ";", "if", "(", "(", "GET_CODE", "(", "mul", ")", "!=", "SET", "||", "GET_CODE", "(", "XEXP", "(", "mul", ",", "1", ")", ")", "!=", "MULT", ")", "||", "(", "GET_CODE", "(", "mac", ")", "!=", "SET", "||", "GET_CODE", "(", "XEXP", "(", "mac", ",", "1", ")", ")", "!=", "PLUS", "||", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "mac", ",", "1", ")", ",", "0", ")", ")", "!=", "MULT", ")", ")", "return", "0", ";", "mul_result", "=", "XEXP", "(", "mul", ",", "0", ")", ";", "mac_op0", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "mac", ",", "1", ")", ",", "0", ")", ",", "0", ")", ";", "mac_op1", "=", "XEXP", "(", "XEXP", "(", "XEXP", "(", "mac", ",", "1", ")", ",", "0", ")", ",", "1", ")", ";", "mac_acc", "=", "XEXP", "(", "XEXP", "(", "mac", ",", "1", ")", ",", "1", ")", ";", "return", "(", "reg_overlap_mentioned_p", "(", "mul_result", ",", "mac_acc", ")", "&&", "!", "reg_overlap_mentioned_p", "(", "mul_result", ",", "mac_op0", ")", "&&", "!", "reg_overlap_mentioned_p", "(", "mul_result", ",", "mac_op1", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "the", "consumer", "(", "a", "multiply-accumulate", "instruction", ")", "has", "an", "accumulator", "dependency", "on", "the", "result", "of", "the", "producer", "(", "a", "multiplication", "instruction", ")", "and", "no", "other", "dependency", "on", "that", "result", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Prepare For LiveIntervals **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "hasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Prepare For LiveIntervals **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "0", "WebAssembly::IMPLICIT_DEF", "WebAssembly::isArgument" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "uint64_t", "FrameSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "for", "(", "int", "ID", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ",", "EID", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "ID", "<", "EID", ";", "ID", "++", ")", "{", "if", "(", "MFI", ".", "getStackID", "(", "ID", ")", "==", "TargetStackID", "::", "RISCVVector", "&&", "!", "MFI", ".", "isDeadObjectIndex", "(", "ID", ")", ")", "{", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "TRI", "->", "getSpillAlignment", "(", "RISCV", "::", "GPRRegClass", ")", ")", ";", "FrameSize", "+=", "TRI", "->", "getSpillSize", "(", "RISCV", "::", "GPRRegClass", ")", ";", "MFI", ".", "setObjectOffset", "(", "ID", ",", "-", "FrameSize", ")", ";", "}", "}", "Align", "StackAlign", "=", "getStackAlign", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "Align", "MaxStackAlign", "=", "std", "::", "max", "(", "StackAlign", ",", "MFI", ".", "getMaxAlign", "(", ")", ")", ";", "FrameSize", "+=", "(", "MaxStackAlign", ".", "value", "(", ")", "-", "StackAlign", ".", "value", "(", ")", ")", ";", "StackAlign", "=", "MaxStackAlign", ";", "}", "uint64_t", "MaxCallSize", "=", "alignTo", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "StackAlign", ")", ";", "MFI", ".", "setMaxCallFrameSize", "(", "MaxCallSize", ")", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", ".", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV::GPRRegClass", "RISCV::GPRRegClass" ]

[]

[ "<s>", "void", "scalar_chain", "::", "emit_conversion_insns", "(", "rtx", "insns", ",", "rtx_insn", "*", "after", ")", "{", "if", "(", "!", "control_flow_insn_p", "(", "after", ")", ")", "{", "emit_insn_after", "(", "insns", ",", "after", ")", ";", "return", ";", "}", "basic_block", "bb", "=", "BLOCK_FOR_INSN", "(", "after", ")", ";", "edge", "e", "=", "find_fallthru_edge", "(", "bb", "->", "succs", ")", ";", "gcc_assert", "(", "e", ")", ";", "basic_block", "new_bb", "=", "split_edge", "(", "e", ")", ";", "emit_insn_after", "(", "insns", ",", "BB_HEAD", "(", "new_bb", ")", ")", ";", "}", "</s>" ]

[ "Insert", "generated", "conversion", "instruction", "sequence", "INSNS", "after", "instruction", "AFTER", ".", "New", "BB", "may", "be", "required", "in", "case", "instruction", "has", "EH", "region", "attached", "." ]

[ "i386" ]

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "PPCSubTarget", "->", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "const", "Module", "*", "M", "=", "MF", "->", "getFunction", "(", ")", "->", "getParent", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", "==", "MVT", "::", "i32", ")", "{", "if", "(", "PPCSubTarget", "->", "isTargetELF", "(", ")", ")", "{", "GlobalBaseReg", "=", "PPC", "::", "R30", ";", "if", "(", "M", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "Small", ")", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MoveGOTtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "else", "{", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "unsigned", "TempReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRCRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "UpdateGBR", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "GlobalBaseReg", ")", ";", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "setUsesPICBase", "(", "true", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i32", "PPC", "PPC::R30", "PPC::MoveGOTtoLR", "PPC::MFLR", "PPC", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::GPRCRegClass", "PPC::UpdateGBR", "PPC", "PPC::GPRC_NOR0RegClass", "PPC::MovePCtoLR", "PPC::MFLR", "PPC::G8RC_NOX0RegClass", "PPC::MovePCtoLR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "bool", "AMDGPUAAResult", "::", "pointsToConstantMemory", "(", "const", "MemoryLocation", "&", "Loc", ",", "AAQueryInfo", "&", "AAQI", ",", "bool", "OrLocal", ")", "{", "unsigned", "AS", "=", "Loc", ".", "Ptr", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "return", "true", ";", "const", "Value", "*", "Base", "=", "GetUnderlyingObject", "(", "Loc", ".", "Ptr", ",", "DL", ")", ";", "AS", "=", "Base", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AS", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "return", "true", ";", "if", "(", "const", "GlobalVariable", "*", "GV", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "Base", ")", ")", "{", "if", "(", "GV", "->", "isConstant", "(", ")", ")", "return", "true", ";", "}", "else", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "Base", ")", ")", "{", "const", "Function", "*", "F", "=", "Arg", "->", "getParent", "(", ")", ";", "switch", "(", "F", "->", "getCallingConv", "(", ")", ")", "{", "default", ":", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "AAQI", ",", "OrLocal", ")", ";", "case", "CallingConv", "::", "AMDGPU_LS", ":", "case", "CallingConv", "::", "AMDGPU_HS", ":", "case", "CallingConv", "::", "AMDGPU_ES", ":", "case", "CallingConv", "::", "AMDGPU_GS", ":", "case", "CallingConv", "::", "AMDGPU_VS", ":", "case", "CallingConv", "::", "AMDGPU_PS", ":", "case", "CallingConv", "::", "AMDGPU_CS", ":", "case", "CallingConv", "::", "AMDGPU_KERNEL", ":", "case", "CallingConv", "::", "SPIR_KERNEL", ":", "break", ";", "}", "unsigned", "ArgNo", "=", "Arg", "->", "getArgNo", "(", ")", ";", "if", "(", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "NoAlias", ")", "&&", "(", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "ReadNone", ")", "||", "F", "->", "hasParamAttribute", "(", "ArgNo", ",", "Attribute", "::", "ReadOnly", ")", ")", ")", "{", "return", "true", ";", "}", "}", "return", "AAResultBase", "::", "pointsToConstantMemory", "(", "Loc", ",", "AAQI", ",", "OrLocal", ")", ";", "}", "</s>" ]

[ "A", "convenience", "wrapper", "around", "the", "primary", "pointsToConstantMemory", "interface", "." ]

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

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstFlags", "(", "MI", ",", "OS", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", "{", "OS", "<<", "\"\\tdata32\"", ";", "}", "else", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "MII", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::DATA16_PREFIX", "X86::Mode16Bit", "\"\\tdata32\"", "X86" ]

[]

[ "<s>", "MipsTargetLowering", "::", "ConstraintType", "MipsTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "case", "'c'", ":", "case", "'l'", ":", "case", "'x'", ":", "return", "C_RegisterClass", ";", "case", "'R'", ":", "return", "C_Memory", ";", "}", "}", "if", "(", "Constraint", "==", "\"ZC\"", ")", "return", "C_Memory", ";", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "1", "0", "\"ZC\"" ]

[]

[ "<s>", "void", "split_ti", "(", "rtx", "operands", "[", "]", ",", "int", "num", ",", "rtx", "lo_half", "[", "]", ",", "rtx", "hi_half", "[", "]", ")", "{", "while", "(", "num", "--", ")", "{", "rtx", "op", "=", "operands", "[", "num", "]", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "lo_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "DImode", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "adjust_address", "(", "op", ",", "DImode", ",", "8", ")", ";", "}", "else", "{", "lo_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "DImode", ",", "op", ",", "TImode", ",", "0", ")", ";", "hi_half", "[", "num", "]", "=", "simplify_gen_subreg", "(", "DImode", ",", "op", ",", "TImode", ",", "8", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "one", "or", "more", "TImode", "RTL", "references", "into", "pairs", "of", "DImode", "references", ".", "The", "RTL", "can", "be", "REG", ",", "offsettable", "MEM", ",", "integer", "constant", ",", "or", "CONST_DOUBLE", ".", "``", "operands", "''", "is", "a", "pointer", "to", "an", "array", "of", "DImode", "RTL", "to", "split", "and", "``", "num", "''", "is", "its", "length", ".", "lo_half", "and", "hi_half", "are", "output", "arrays", "that", "parallel", "``", "operands", "''", "." ]

[ "i386", "0", "8", "0", "8" ]

[]

[ "<s>", "const", "uint32_t", "*", "Z80oldRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "CSR_Z80old_C_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "case", "CallingConv", "::", "Z80_LibCall", ":", "case", "CallingConv", "::", "Z80_LibCall_AC", ":", "case", "CallingConv", "::", "Z80_LibCall_BC", ":", "case", "CallingConv", "::", "Z80_LibCall_C", ":", "case", "CallingConv", "::", "Z80_LibCall_L", ":", "return", "CSR_Z80old_AllRegs_RegMask", ";", "}", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "Z80old", "Z80old", "\"Unsupported calling convention\"", "Z80old", "Z80old" ]

[]

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

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

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

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "isEntryFunction", "(", ")", ")", "return", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "for", "(", "const", "SIMachineFunctionInfo", "::", "SGPRSpillVGPRCSR", "&", "Reg", ":", "FuncInfo", "->", "getSGPRSpillVGPRs", "(", ")", ")", "{", "if", "(", "!", "Reg", ".", "FI", ".", "hasValue", "(", ")", ")", "continue", ";", "TII", "->", "loadRegFromStackSlot", "(", "MBB", ",", "MBBI", ",", "Reg", ".", "VGPR", ",", "Reg", ".", "FI", ".", "getValue", "(", ")", ",", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "&", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "}", "unsigned", "StackPtrReg", "=", "FuncInfo", "->", "getStackPtrOffsetReg", "(", ")", ";", "if", "(", "StackPtrReg", "==", "AMDGPU", "::", "NoRegister", ")", "return", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "uint32_t", "NumBytes", "=", "MFI", ".", "getStackSize", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "NumBytes", "!=", "0", "&&", "hasSP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "StackPtrReg", ")", ".", "addReg", "(", "StackPtrReg", ")", ".", "addImm", "(", "NumBytes", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "AMDGPU::VGPR_32RegClass", "AMDGPU::NoRegister", "0", "AMDGPU::S_SUB_U32" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "MachineOperand", "&", "MO", "=", "Cond", "[", "1", "]", ";", "switch", "(", "MO", ".", "getImm", "(", ")", ")", "{", "case", "AMDGPU", "::", "PRED_SETE_INT", ":", "MO", ".", "setImm", "(", "AMDGPU", "::", "PRED_SETNE_INT", ")", ";", "break", ";", "case", "AMDGPU", "::", "PRED_SETNE_INT", ":", "MO", ".", "setImm", "(", "AMDGPU", "::", "PRED_SETE_INT", ")", ";", "break", ";", "case", "AMDGPU", "::", "PRED_SETE", ":", "MO", ".", "setImm", "(", "AMDGPU", "::", "PRED_SETNE", ")", ";", "break", ";", "case", "AMDGPU", "::", "PRED_SETNE", ":", "MO", ".", "setImm", "(", "AMDGPU", "::", "PRED_SETE", ")", ";", "break", ";", "default", ":", "return", "true", ";", "}", "MachineOperand", "&", "MO2", "=", "Cond", "[", "2", "]", ";", "switch", "(", "MO2", ".", "getReg", "(", ")", ")", "{", "case", "AMDGPU", "::", "PRED_SEL_ZERO", ":", "MO2", ".", "setReg", "(", "AMDGPU", "::", "PRED_SEL_ONE", ")", ";", "break", ";", "case", "AMDGPU", "::", "PRED_SEL_ONE", ":", "MO2", ".", "setReg", "(", "AMDGPU", "::", "PRED_SEL_ZERO", ")", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "AMDGPU", "R600", "1", "AMDGPU::PRED_SETE_INT", "AMDGPU::PRED_SETNE_INT", "AMDGPU::PRED_SETNE_INT", "AMDGPU::PRED_SETE_INT", "AMDGPU::PRED_SETE", "AMDGPU::PRED_SETNE", "AMDGPU::PRED_SETNE", "AMDGPU::PRED_SETE", "2", "AMDGPU::PRED_SEL_ZERO", "AMDGPU::PRED_SEL_ONE", "AMDGPU::PRED_SEL_ONE", "AMDGPU::PRED_SEL_ZERO" ]

[]

[ "<s>", "static", "void", "aarch64_add_offset_1", "(", "scalar_int_mode", "mode", ",", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "offset", ",", "rtx", "temp1", ",", "bool", "frame_related_p", ",", "bool", "emit_move_imm", ")", "{", "gcc_assert", "(", "emit_move_imm", "||", "temp1", "!=", "NULL_RTX", ")", ";", "gcc_assert", "(", "temp1", "==", "NULL_RTX", "||", "!", "reg_overlap_mentioned_p", "(", "temp1", ",", "src", ")", ")", ";", "unsigned", "HOST_WIDE_INT", "moffset", "=", "absu_hwi", "(", "offset", ")", ";", "rtx_insn", "*", "insn", ";", "if", "(", "!", "moffset", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "dest", ",", "src", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "src", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "}", "return", ";", "}", "if", "(", "aarch64_uimm12_shift", "(", "moffset", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "src", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "return", ";", "}", "if", "(", "moffset", "<", "0x1000000", "&&", "(", "(", "!", "temp1", "&&", "!", "can_create_pseudo_p", "(", ")", ")", "||", "!", "aarch64_move_imm", "(", "moffset", ",", "mode", ")", ")", ")", "{", "HOST_WIDE_INT", "low_off", "=", "moffset", "&", "0xfff", ";", "low_off", "=", "offset", "<", "0", "?", "-", "low_off", ":", "low_off", ";", "insn", "=", "emit_insn", "(", "gen_add3_insn", "(", "dest", ",", "src", ",", "GEN_INT", "(", "low_off", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "insn", "=", "emit_insn", "(", "gen_add2_insn", "(", "dest", ",", "GEN_INT", "(", "offset", "-", "low_off", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "return", ";", "}", "if", "(", "emit_move_imm", ")", "{", "gcc_assert", "(", "temp1", "!=", "NULL_RTX", "||", "can_create_pseudo_p", "(", ")", ")", ";", "temp1", "=", "aarch64_force_temporary", "(", "mode", ",", "temp1", ",", "gen_int_mode", "(", "moffset", ",", "mode", ")", ")", ";", "}", "insn", "=", "emit_insn", "(", "offset", "<", "0", "?", "gen_sub3_insn", "(", "dest", ",", "src", ",", "temp1", ")", ":", "gen_add3_insn", "(", "dest", ",", "src", ",", "temp1", ")", ")", ";", "if", "(", "frame_related_p", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "frame_related_p", ";", "rtx", "adj", "=", "plus_constant", "(", "mode", ",", "src", ",", "offset", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "dest", ",", "adj", ")", ")", ";", "}", "}", "</s>" ]

[ "A", "subroutine", "of", "aarch64_add_offset", ".", "Set", "DEST", "to", "SRC", "+", "OFFSET", "for", "a", "non-polynomial", "OFFSET", ".", "MODE", "is", "the", "mode", "of", "the", "addition", ".", "FRAME_RELATED_P", "is", "true", "if", "the", "RTX_FRAME_RELATED", "flag", "should", "be", "set", "and", "CFA", "adjustments", "added", "to", "the", "generated", "instructions", ".", "TEMP1", ",", "if", "nonnull", ",", "is", "a", "register", "of", "mode", "MODE", "that", "can", "be", "used", "as", "a", "temporary", "if", "register", "allocation", "is", "already", "complete", ".", "This", "temporary", "register", "may", "overlap", "DEST", "but", "must", "not", "overlap", "SRC", ".", "If", "TEMP1", "is", "known", "to", "hold", "abs", "(", "OFFSET", ")", ",", "EMIT_MOVE_IMM", "can", "be", "set", "to", "false", "to", "avoid", "emitting", "the", "immediate", "again", ".", "Since", "this", "function", "may", "be", "used", "to", "adjust", "the", "stack", "pointer", ",", "we", "must", "ensure", "that", "it", "can", "not", "cause", "transient", "stack", "deallocation", "(", "for", "example", "by", "first", "incrementing", "SP", "and", "then", "decrementing", "when", "adjusting", "by", "a", "large", "immediate", ")", "." ]

[ "aarch64", "0x1000000", "0xfff", "0", "0" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "emitTargetAttributes", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "STI", ".", "hasFeature", "(", "RISCV", "::", "FeatureRV32E", ")", ")", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_4", ")", ";", "else", "emitAttribute", "(", "RISCVAttrs", "::", "STACK_ALIGN", ",", "RISCVAttrs", "::", "ALIGN_16", ")", ";", "unsigned", "XLen", "=", "STI", ".", "hasFeature", "(", "RISCV", "::", "Feature64Bit", ")", "?", "64", ":", "32", ";", "std", "::", "vector", "<", "std", "::", "string", ">", "FeatureVector", ";", "RISCVFeatures", "::", "toFeatureVector", "(", "FeatureVector", ",", "STI", ".", "getFeatureBits", "(", ")", ")", ";", "auto", "ParseResult", "=", "llvm", "::", "RISCVISAInfo", "::", "parseFeatures", "(", "XLen", ",", "FeatureVector", ")", ";", "if", "(", "!", "ParseResult", ")", "{", "consumeError", "(", "ParseResult", ".", "takeError", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Parsing feature error when emitTargetAttributes?\"", ")", ";", "}", "else", "{", "auto", "&", "ISAInfo", "=", "*", "ParseResult", ";", "emitTextAttribute", "(", "RISCVAttrs", "::", "ARCH", ",", "ISAInfo", "->", "toString", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureRV32E", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_4", "RISCVAttrs::STACK_ALIGN", "RISCVAttrs::ALIGN_16", "RISCV::Feature64Bit", "64", "32", "RISCVFeatures::toFeatureVector", "RISCVISAInfo::parseFeatures", "\"Parsing feature error when emitTargetAttributes?\"", "RISCVAttrs::ARCH" ]

[]

[ "<s>", "bool", "m32c_mov_ok", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "op0", "=", "operands", "[", "0", "]", ";", "rtx", "op1", "=", "operands", "[", "1", "]", ";", "if", "(", "TARGET_A24", ")", "return", "true", ";", "fprintf", "(", "stderr", ",", "\"m32c_mov_ok %s\\n\"", ",", "mode_name", "[", "mode", "]", ")", ";", "debug_rtx", "(", "op0", ")", ";", "debug_rtx", "(", "op1", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "SUBREG", ")", "op0", "=", "XEXP", "(", "op0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "SUBREG", ")", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", "&&", "!", "reload_completed", ")", "{", "fprintf", "(", "stderr", ",", "\" - no, mem to mem\\n\"", ")", ";", "return", "false", ";", "}", "fprintf", "(", "stderr", ",", "\" - ok\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "we", "support", "a", "move", "between", "the", "first", "two", "operands", ".", "At", "the", "moment", ",", "we", "just", "want", "to", "discourage", "mem", "to", "mem", "moves", "until", "after", "reload", ",", "because", "reload", "has", "a", "hard", "time", "with", "our", "limited", "number", "of", "address", "registers", ",", "and", "we", "can", "get", "into", "a", "situation", "where", "we", "need", "three", "of", "them", "when", "we", "only", "have", "two", "." ]

[ "m32c", "0", "1", "\"m32c_mov_ok %s\\n\"", "0", "0", "\" - no, mem to mem\\n\"", "\" - ok\\n\"" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldExpandGetActiveLaneMask", "(", "EVT", "ResVT", ",", "EVT", "OpVT", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasSVE", "(", ")", ")", "return", "true", ";", "if", "(", "ResVT", "!=", "MVT", "::", "nxv2i1", "&&", "ResVT", "!=", "MVT", "::", "nxv4i1", "&&", "ResVT", "!=", "MVT", "::", "nxv8i1", "&&", "ResVT", "!=", "MVT", "::", "nxv16i1", "&&", "ResVT", "!=", "MVT", "::", "v2i1", "&&", "ResVT", "!=", "MVT", "::", "v4i1", "&&", "ResVT", "!=", "MVT", "::", "v8i1", "&&", "ResVT", "!=", "MVT", "::", "v16i1", ")", "return", "true", ";", "if", "(", "OpVT", "!=", "MVT", "::", "i32", "&&", "OpVT", "!=", "MVT", "::", "i64", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "@", "llvm.get.active.lane.mask", "intrinsic", "should", "be", "expanded", "using", "generic", "code", "in", "SelectionDAGBuilder", "." ]

[ "AArch64", "AArch64", "MVT::nxv2i1", "MVT::nxv4i1", "MVT::nxv8i1", "MVT::nxv16i1", "MVT::v2i1", "MVT::v4i1", "MVT::v8i1", "MVT::v16i1", "MVT::i32", "MVT::i64" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreSched2", "(", ")", "{", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "gimple", "*", "gimple_folder", "::", "fold_to_pfalse", "(", ")", "{", "return", "gimple_build_assign", "(", "lhs", ",", "build_zero_cst", "(", "TREE_TYPE", "(", "lhs", ")", ")", ")", ";", "}", "</s>" ]

[ "Fold", "the", "call", "to", "a", "PFALSE", "." ]

[ "aarch64" ]

[]

[ "<s>", "Optional", "<", "RegImmPair", ">", "AArch64InstrInfo", "::", "isAddImmediate", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "Reg", ")", "const", "{", "int", "Sign", "=", "1", ";", "int64_t", "Offset", "=", "0", ";", "const", "MachineOperand", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "!", "Op0", ".", "isReg", "(", ")", "||", "Reg", "!=", "Op0", ".", "getReg", "(", ")", ")", "return", "None", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "None", ";", "case", "AArch64", "::", "SUBWri", ":", "case", "AArch64", "::", "SUBXri", ":", "case", "AArch64", "::", "SUBSWri", ":", "case", "AArch64", "::", "SUBSXri", ":", "Sign", "*=", "-", "1", ";", "LLVM_FALLTHROUGH", ";", "case", "AArch64", "::", "ADDSWri", ":", "case", "AArch64", "::", "ADDSXri", ":", "case", "AArch64", "::", "ADDWri", ":", "case", "AArch64", "::", "ADDXri", ":", "{", "if", "(", "!", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "None", ";", "int", "Shift", "=", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "assert", "(", "(", "Shift", "==", "0", "||", "Shift", "==", "12", ")", "&&", "\"Shift can be either 0 or 12\"", ")", ";", "Offset", "=", "Sign", "*", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<<", "Shift", ")", ";", "}", "}", "return", "RegImmPair", "{", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ",", "Offset", "}", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "an", "instruction", "that", "adds", "an", "immediate", "value", "and", "a", "register", ",", "and", "stores", "the", "result", "in", "the", "given", "register", "Reg", ",", "return", "a", "pair", "of", "the", "source", "register", "and", "the", "offset", "which", "has", "been", "added", "." ]

[ "AArch64", "AArch64", "1", "0", "0", "AArch64::SUBWri", "AArch64::SUBXri", "AArch64::SUBSWri", "AArch64::SUBSXri", "1", "AArch64::ADDSWri", "AArch64::ADDSXri", "AArch64::ADDWri", "AArch64::ADDXri", "0", "1", "2", "3", "0", "12", "\"Shift can be either 0 or 12\"", "2", "1" ]

[]

[ "<s>", "const", "MCExpr", "*", "M68kTargetLowering", "::", "getPICJumpTableRelocBaseExpr", "(", "const", "MachineFunction", "*", "MF", ",", "unsigned", "JTI", ",", "MCContext", "&", "Ctx", ")", "const", "{", "return", "MCSymbolRefExpr", "::", "create", "(", "MF", "->", "getJTISymbol", "(", "JTI", ",", "Ctx", ")", ",", "Ctx", ")", ";", "}", "</s>" ]

[ "This", "returns", "the", "relocation", "base", "for", "the", "given", "PIC", "jumptable", ",", "the", "same", "as", "getPICJumpTableRelocBase", ",", "but", "as", "an", "MCExpr", "." ]

[ "M68k", "M68k" ]

[]

[ "<s>", "int", "m32c_register_move_cost", "(", "enum", "machine_mode", "mode", ",", "int", "from", ",", "int", "to", ")", "{", "int", "cost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "int", "cc", "=", "class_contents", "[", "from", "]", "[", "0", "]", "|", "class_contents", "[", "to", "]", "[", "0", "]", ";", "if", "(", "mode", "==", "QImode", "&&", "(", "cc", "&", "class_contents", "[", "R23_REGS", "]", "[", "0", "]", ")", ")", "{", "if", "(", "!", "(", "cc", "&", "~", "class_contents", "[", "R23_REGS", "]", "[", "0", "]", ")", ")", "cost", "=", "COSTS_N_INSNS", "(", "1000", ")", ";", "else", "cost", "=", "COSTS_N_INSNS", "(", "80", ")", ";", "}", "if", "(", "!", "class_can_hold_mode", "(", "from", ",", "mode", ")", "||", "!", "class_can_hold_mode", "(", "to", ",", "mode", ")", ")", "cost", "=", "COSTS_N_INSNS", "(", "1000", ")", ";", "if", "(", "classes_intersect", "(", "from", ",", "CR_REGS", ")", ")", "cost", "+=", "COSTS_N_INSNS", "(", "5", ")", ";", "if", "(", "classes_intersect", "(", "to", ",", "CR_REGS", ")", ")", "cost", "+=", "COSTS_N_INSNS", "(", "5", ")", ";", "if", "(", "from", "==", "MEM_REGS", "||", "to", "==", "MEM_REGS", ")", "cost", "+=", "COSTS_N_INSNS", "(", "50", ")", ";", "else", "if", "(", "classes_intersect", "(", "from", ",", "MEM_REGS", ")", "||", "classes_intersect", "(", "to", ",", "MEM_REGS", ")", ")", "cost", "+=", "COSTS_N_INSNS", "(", "10", ")", ";", "fprintf", "(", "stderr", ",", "\"register_move_cost %s from %s to %s = %d\\n\"", ",", "mode_name", "[", "mode", "]", ",", "class_names", "[", "from", "]", ",", "class_names", "[", "to", "]", ",", "cost", ")", ";", "return", "cost", ";", "}", "</s>" ]

[ "Implements", "REGISTER_MOVE_COST", ".", "We", "make", "impossible", "moves", "prohibitively", "expensive", ",", "like", "trying", "to", "put", "QIs", "in", "r2/r3", "(", "there", "are", "no", "opcodes", "to", "do", "that", ")", ".", "We", "also", "discourage", "use", "of", "mem", "*", "registers", "since", "they", "'re", "really", "memory", "." ]

[ "m32c", "3", "0", "0", "0", "0", "1000", "80", "1000", "5", "5", "50", "10", "\"register_move_cost %s from %s to %s = %d\\n\"" ]

[]

[ "<s>", "static", "rtx", "emit_new_cond_insn", "(", "rtx", "insn", ",", "int", "cond", ")", "{", "rtx", "c_insn", "=", "0", ";", "rtx", "pat", ",", "dst", ",", "src", ";", "cond_type", "num", ";", "if", "(", "(", "num", "=", "is_cond_candidate", "(", "insn", ")", ")", "==", "COND_NO", ")", "return", "NULL", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "insn", ")", "==", "INSN", ")", "{", "dst", "=", "SET_DEST", "(", "pat", ")", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "}", "else", "{", "dst", "=", "JUMP_LABEL", "(", "insn", ")", ";", "src", "=", "NULL_RTX", ";", "}", "switch", "(", "num", ")", "{", "case", "COND_MOV_INSN", ":", "case", "COND_CLR_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_movt0", "(", "dst", ",", "src", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_movt0", "(", "dst", ",", "dst", ",", "src", ")", ";", "break", ";", "case", "COND_INC_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_incscc", "(", "dst", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_incscc_false", "(", "dst", ",", "dst", ")", ";", "break", ";", "case", "COND_DEC_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_decscc", "(", "dst", ",", "dst", ")", ";", "else", "c_insn", "=", "gen_decscc_false", "(", "dst", ",", "dst", ")", ";", "break", ";", "case", "COND_BRANCH_INSN", ":", "if", "(", "cond", ")", "c_insn", "=", "gen_branch_true", "(", "dst", ")", ";", "else", "c_insn", "=", "gen_branch_false", "(", "dst", ")", ";", "break", ";", "default", ":", "return", "NULL", ";", "}", "if", "(", "rtx_length", "[", "GET_CODE", "(", "c_insn", ")", "]", ">=", "7", "&&", "rtx_length", "[", "GET_CODE", "(", "insn", ")", "]", ">=", "7", ")", "{", "REG_NOTES", "(", "c_insn", ")", "=", "REG_NOTES", "(", "insn", ")", ";", "}", "if", "(", "num", "==", "COND_BRANCH_INSN", ")", "{", "c_insn", "=", "emit_jump_insn_before", "(", "c_insn", ",", "insn", ")", ";", "++", "LABEL_NUSES", "(", "dst", ")", ";", "JUMP_LABEL", "(", "c_insn", ")", "=", "dst", ";", "}", "else", "c_insn", "=", "emit_insn_after", "(", "c_insn", ",", "insn", ")", ";", "delete_insn", "(", "insn", ")", ";", "return", "c_insn", ";", "}", "</s>" ]

[ "Emit", "a", "conditional", "version", "of", "insn", "and", "replace", "the", "old", "insn", "with", "the", "new", "one", ".", "Return", "the", "new", "insn", "if", "emitted", "." ]

[ "mcore", "0", "7", "7" ]

[]

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

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

[ "Xtensa", "Xtensa" ]

[]