Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "MCExpr", "*", "X86ELFTargetObjectFile", "::", "getDebugThreadLocalSymbol", "(", "const", "MCSymbol", "*", "Sym", ")", "const", "{", "return", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_DTPOFF", ",", "getContext", "(", ")", ")", ";", "}", "</s>" ]

[ "Describe", "a", "TLS", "variable", "address", "within", "debug", "info", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "SystemZHazardRecognizer", "::", "emitInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "TakenBranch", ")", "{", "SUnit", "SU", "(", "MI", ",", "0", ")", ";", "SU", ".", "isCall", "=", "MI", "->", "isCall", "(", ")", ";", "const", "MCSchedClassDesc", "*", "SC", "=", "SchedModel", "->", "resolveSchedClass", "(", "MI", ")", ";", "for", "(", "const", "MCWriteProcResEntry", "&", "PRE", ":", "make_range", "(", "SchedModel", "->", "getWriteProcResBegin", "(", "SC", ")", ",", "SchedModel", "->", "getWriteProcResEnd", "(", "SC", ")", ")", ")", "{", "switch", "(", "SchedModel", "->", "getProcResource", "(", "PRE", ".", "ProcResourceIdx", ")", "->", "BufferSize", ")", "{", "case", "0", ":", "SU", ".", "hasReservedResource", "=", "true", ";", "break", ";", "case", "1", ":", "SU", ".", "isUnbuffered", "=", "true", ";", "break", ";", "default", ":", "break", ";", "}", "}", "EmitInstruction", "(", "&", "SU", ")", ";", "if", "(", "TakenBranch", "&&", "CurrGroupSize", ">", "0", ")", "nextGroup", "(", "false", ")", ";", "assert", "(", "(", "!", "MI", "->", "isTerminator", "(", ")", "||", "isBranchRetTrap", "(", "MI", ")", ")", "&&", "\"Scheduler: unhandled terminator!\"", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "0", "1", "0", "\"Scheduler: unhandled terminator!\"" ]

[]

[ "<s>", "void", "mips_init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ")", "{", "memset", "(", "cum", ",", "0", ",", "sizeof", "(", "*", "cum", ")", ")", ";", "cum", "->", "prototype", "=", "(", "fntype", "&&", "prototype_p", "(", "fntype", ")", ")", ";", "cum", "->", "gp_reg_found", "=", "(", "cum", "->", "prototype", "&&", "stdarg_p", "(", "fntype", ")", ")", ";", "}", "</s>" ]

[ "Initialize", "*", "CUM", "for", "a", "call", "to", "a", "function", "of", "type", "FNTYPE", "." ]

[ "mips", "0" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTargetOpValueMMPC10", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "1", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTargetOpValuePC10 expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTargetOpValueMMPC10", "-", "Return", "binary", "encoding", "of", "the", "microMIPS", "10-bit", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "1", "\"getBranchTargetOpValuePC10 expects only expressions or immediates\"", "0", "Mips::fixup_MICROMIPS_PC10_S1", "0" ]

[]

[ "<s>", "void", "get_aligned_mem", "(", "rtx", "ref", ",", "rtx", "*", "paligned_mem", ",", "rtx", "*", "pbitnum", ")", "{", "rtx", "base", ";", "HOST_WIDE_INT", "disp", ",", "offset", ";", "gcc_assert", "(", "MEM_P", "(", "ref", ")", ")", ";", "if", "(", "reload_in_progress", "&&", "!", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "XEXP", "(", "ref", ",", "0", ")", ")", ")", "{", "base", "=", "find_replacement", "(", "&", "XEXP", "(", "ref", ",", "0", ")", ")", ";", "gcc_assert", "(", "memory_address_p", "(", "GET_MODE", "(", "ref", ")", ",", "base", ")", ")", ";", "}", "else", "base", "=", "XEXP", "(", "ref", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ",", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "else", "disp", "=", "0", ";", "if", "(", "MEM_ALIGN", "(", "ref", ")", ">=", "32", ")", "offset", "=", "0", ";", "else", "offset", "=", "disp", "&", "3", ";", "gcc_assert", "(", "offset", "+", "GET_MODE_SIZE", "(", "GET_MODE", "(", "ref", ")", ")", "<=", "GET_MODE_SIZE", "(", "SImode", ")", ")", ";", "*", "paligned_mem", "=", "widen_memory_access", "(", "ref", ",", "SImode", ",", "-", "offset", ")", ";", "offset", "*=", "BITS_PER_UNIT", ";", "*", "pbitnum", "=", "GEN_INT", "(", "offset", ")", ";", "}", "</s>" ]

[ "REF", "is", "an", "alignable", "memory", "location", ".", "Place", "an", "aligned", "SImode", "reference", "into", "*", "PALIGNED_MEM", "and", "the", "number", "of", "bits", "to", "shift", "into", "*", "PBITNUM", ".", "SCRATCH", "is", "a", "free", "register", "for", "use", "in", "reloading", "out", "of", "range", "stack", "slots", "." ]

[ "alpha", "0", "0", "0", "1", "0", "0", "32", "0", "3" ]

[]

[ "<s>", "void", "VideocoreAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "O", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "O", ")", ";", "return", ";", "}", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "128" ]

[]

[ "<s>", "SDValue", "SparcTargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "return", "LowerCall_64", "(", "CLI", ",", "InVals", ")", ";", "return", "LowerCall_32", "(", "CLI", ",", "InVals", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", "->", "getTarget", "(", ")", ")", ";", "if", "(", "TM", ".", "isPositionIndependent", "(", ")", ")", "report_fatal_error", "(", "\"Unable to insert indirect branch\"", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "BrOffset", ")", ")", "report_fatal_error", "(", "\"Branch offsets outside of the signed 32-bit range not supported\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "auto", "II", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "&", "LuiMI", "=", "*", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "RISCV", "::", "LUI", ")", ",", "ScratchReg", ")", ".", "addMBB", "(", "&", "DestBB", ",", "RISCVII", "::", "MO_HI", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoBRIND", ")", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Kill", ")", ".", "addMBB", "(", "&", "DestBB", ",", "RISCVII", "::", "MO_LO", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "unsigned", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "RISCV", "::", "GPRRegClass", ",", "LuiMI", ".", "getIterator", "(", ")", ",", "false", ",", "0", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "return", "8", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "RISCV", "RISCV", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "RISCV", "\"Unable to insert indirect branch\"", "32", "\"Branch offsets outside of the signed 32-bit range not supported\"", "RISCV::GPRRegClass", "RISCV::LUI", "RISCVII::MO_HI", "RISCV::PseudoBRIND", "RISCVII::MO_LO", "RISCV::GPRRegClass", "0", "8" ]

[]

[ "<s>", "static", "void", "indirect_thunk_name", "(", "char", "name", "[", "32", "]", ",", "unsigned", "int", "regno", ",", "enum", "indirect_thunk_prefix", "need_prefix", ",", "bool", "ret_p", ")", "{", "if", "(", "regno", "!=", "INVALID_REGNUM", "&&", "regno", "!=", "CX_REG", "&&", "ret_p", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "USE_HIDDEN_LINKONCE", ")", "{", "const", "char", "*", "prefix", ";", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "prefix", "=", "\"_bnd\"", ";", "else", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_nt", "&&", "regno", "!=", "INVALID_REGNUM", ")", "{", "prefix", "=", "\"_nt\"", ";", "}", "else", "prefix", "=", "\"\"", ";", "const", "char", "*", "ret", "=", "ret_p", "?", "\"return\"", ":", "\"indirect\"", ";", "if", "(", "regno", "!=", "INVALID_REGNUM", ")", "{", "const", "char", "*", "reg_prefix", ";", "if", "(", "LEGACY_INT_REGNO_P", "(", "regno", ")", ")", "reg_prefix", "=", "TARGET_64BIT", "?", "\"r\"", ":", "\"e\"", ";", "else", "reg_prefix", "=", "\"\"", ";", "sprintf", "(", "name", ",", "\"__x86_%s_thunk%s_%s%s\"", ",", "ret", ",", "prefix", ",", "reg_prefix", ",", "reg_names", "[", "regno", "]", ")", ";", "}", "else", "sprintf", "(", "name", ",", "\"__x86_%s_thunk%s\"", ",", "ret", ",", "prefix", ")", ";", "}", "else", "{", "if", "(", "regno", "!=", "INVALID_REGNUM", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LITBR\"", ",", "regno", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LITR\"", ",", "regno", ")", ";", "}", "else", "{", "if", "(", "ret_p", ")", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LRTB\"", ",", "0", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LRT\"", ",", "0", ")", ";", "}", "else", "{", "if", "(", "need_prefix", "==", "indirect_thunk_prefix_bnd", ")", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LITB\"", ",", "0", ")", ";", "else", "ASM_GENERATE_INTERNAL_LABEL", "(", "name", ",", "\"LIT\"", ",", "0", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Fills", "in", "the", "label", "name", "that", "should", "be", "used", "for", "the", "indirect", "thunk", "." ]

[ "i386", "32", "\"_bnd\"", "\"_nt\"", "\"\"", "\"return\"", "\"indirect\"", "\"r\"", "\"e\"", "\"\"", "\"__x86_%s_thunk%s_%s%s\"", "\"__x86_%s_thunk%s\"", "\"LITBR\"", "\"LITR\"", "\"LRTB\"", "0", "\"LRT\"", "0", "\"LITB\"", "0", "\"LIT\"", "0" ]

[]

[ "<s>", "unsigned", "PPCAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "int64_t", "ImmVal", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_0", ":", "ImmVal", "=", "0", ";", "break", ";", "case", "MCK_1", ":", "ImmVal", "=", "1", ";", "break", ";", "case", "MCK_2", ":", "ImmVal", "=", "2", ";", "break", ";", "case", "MCK_3", ":", "ImmVal", "=", "3", ";", "break", ";", "default", ":", "return", "Match_InvalidOperand", ";", "}", "PPCOperand", "&", "Op", "=", "static_cast", "<", "PPCOperand", "&", ">", "(", "AsmOp", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", "&&", "Op", ".", "getImm", "(", ")", "==", "ImmVal", ")", "return", "Match_Success", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "PowerPC", "PPC", "0", "1", "2", "3", "PPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "promote_duplicated_reg", "(", "machine_mode", "mode", ",", "rtx", "val", ")", "{", "machine_mode", "valmode", "=", "GET_MODE", "(", "val", ")", ";", "rtx", "tmp", ";", "int", "nops", "=", "mode", "==", "DImode", "?", "3", ":", "2", ";", "gcc_assert", "(", "mode", "==", "SImode", "||", "mode", "==", "DImode", "||", "val", "==", "const0_rtx", ")", ";", "if", "(", "val", "==", "const0_rtx", ")", "return", "copy_to_mode_reg", "(", "mode", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "val", ")", ")", "{", "HOST_WIDE_INT", "v", "=", "INTVAL", "(", "val", ")", "&", "255", ";", "v", "|=", "v", "<<", "8", ";", "v", "|=", "v", "<<", "16", ";", "if", "(", "mode", "==", "DImode", ")", "v", "|=", "(", "v", "<<", "16", ")", "<<", "16", ";", "return", "copy_to_mode_reg", "(", "mode", ",", "gen_int_mode", "(", "v", ",", "mode", ")", ")", ";", "}", "if", "(", "valmode", "==", "VOIDmode", ")", "valmode", "=", "QImode", ";", "if", "(", "valmode", "!=", "QImode", ")", "val", "=", "gen_lowpart", "(", "QImode", ",", "val", ")", ";", "if", "(", "mode", "==", "QImode", ")", "return", "val", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "nops", "--", ";", "if", "(", "ix86_cost", "->", "mult_init", "[", "mode", "==", "DImode", "?", "3", ":", "2", "]", "+", "ix86_cost", "->", "mult_bit", "*", "(", "mode", "==", "DImode", "?", "8", ":", "4", ")", "<=", "(", "ix86_cost", "->", "shift_const", "+", "ix86_cost", "->", "add", ")", "*", "nops", "+", "(", "COSTS_N_INSNS", "(", "TARGET_PARTIAL_REG_STALL", "==", "0", ")", ")", ")", "{", "rtx", "reg", "=", "convert_modes", "(", "mode", ",", "QImode", ",", "val", ",", "true", ")", ";", "tmp", "=", "promote_duplicated_reg", "(", "mode", ",", "const1_rtx", ")", ";", "return", "expand_simple_binop", "(", "mode", ",", "MULT", ",", "reg", ",", "tmp", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "else", "{", "rtx", "reg", "=", "convert_modes", "(", "mode", ",", "QImode", ",", "val", ",", "true", ")", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "if", "(", "mode", "==", "SImode", ")", "emit_insn", "(", "gen_movsi_insv_1", "(", "reg", ",", "reg", ")", ")", ";", "else", "emit_insn", "(", "gen_movdi_insv_1", "(", "reg", ",", "reg", ")", ")", ";", "else", "{", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFT", ",", "reg", ",", "GEN_INT", "(", "8", ")", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "reg", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "reg", ",", "tmp", ",", "reg", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFT", ",", "reg", ",", "GEN_INT", "(", "16", ")", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "reg", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "reg", ",", "tmp", ",", "reg", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "mode", "==", "SImode", ")", "return", "reg", ";", "tmp", "=", "expand_simple_binop", "(", "mode", ",", "ASHIFT", ",", "reg", ",", "GEN_INT", "(", "32", ")", ",", "NULL", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "reg", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "reg", ",", "tmp", ",", "reg", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "return", "reg", ";", "}", "}", "</s>" ]

[ "Helper", "function", "for", "memcpy", ".", "For", "QImode", "value", "0xXY", "produce", "0xXYXYXYXY", "of", "wide", "specified", "by", "MODE", ".", "This", "is", "essentially", "a", "*", "0x10101010", ",", "but", "we", "can", "do", "slightly", "better", "than", "synth_mult", "by", "unwinding", "the", "sequence", "by", "hand", "on", "CPUs", "with", "slow", "multiply", "." ]

[ "i386", "3", "2", "255", "8", "16", "16", "16", "3", "2", "8", "4", "0", "1", "8", "1", "1", "16", "1", "1", "32", "1", "1" ]

[]

[ "<s>", "static", "void", "nvptx_maybe_record_fnsym", "(", "rtx", "sym", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "sym", ")", ";", "if", "(", "decl", "&&", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", "&&", "DECL_EXTERNAL", "(", "decl", ")", ")", "nvptx_record_needed_fndecl", "(", "decl", ")", ";", "}", "</s>" ]

[ "SYM", "is", "a", "SYMBOL_REF", ".", "If", "it", "refers", "to", "an", "external", "function", ",", "record", "it", "as", "needed", "." ]

[ "nvptx" ]

[]

[ "<s>", "unsigned", "PPCTargetLowering", "::", "getByValTypeAlignment", "(", "Type", "*", "Ty", ",", "const", "DataLayout", "&", "DL", ")", "const", "{", "unsigned", "Align", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "8", ":", "4", ";", "if", "(", "Subtarget", ".", "hasAltivec", "(", ")", "||", "Subtarget", ".", "hasQPX", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ",", "Subtarget", ".", "hasQPX", "(", ")", "?", "32", ":", "16", ")", ";", "return", "Align", ";", "}", "</s>" ]

[ "Return", "the", "desired", "alignment", "for", "ByVal", "aggregate", "function", "arguments", "in", "the", "caller", "parameter", "area", "." ]

[ "PowerPC", "PPC", "PPC", "8", "4", "32", "16" ]

[]

[ "<s>", "const", "uint16_t", "*", "AVRRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", "->", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "if", "(", "STI", ".", "hasTinyEncoding", "(", ")", ")", "return", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "CSR_InterruptsTiny_SaveList", ":", "CSR_NormalTiny_SaveList", ";", "else", "return", "AFI", "->", "isInterruptOrSignalHandler", "(", ")", "?", "CSR_Interrupts_SaveList", ":", "CSR_Normal_SaveList", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR", "AVR", "AVR", "AVR" ]

[]

[ "<s>", "static", "rtx", "aarch64_gen_loadwb_pair", "(", "machine_mode", "mode", ",", "rtx", "base", ",", "rtx", "reg", ",", "rtx", "reg2", ",", "HOST_WIDE_INT", "adjustment", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "gen_loadwb_pairdi_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "case", "E_DFmode", ":", "return", "gen_loadwb_pairdf_di", "(", "base", ",", "base", ",", "reg", ",", "reg2", ",", "GEN_INT", "(", "adjustment", ")", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "pair", "of", "register", "REG", ",", "REG2", "of", "mode", "MODE", "from", "stack", "location", "BASE", ",", "adjusting", "it", "by", "ADJUSTMENT", "afterwards", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "s390_asm_output_function_prefix", "(", "FILE", "*", "asm_out_file", ",", "const", "char", "*", "fnname", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "current_function_decl", ")", "==", "NULL", ")", "return", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machinemode push\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.machine push\\n\"", ")", ";", "s390_asm_output_machine_for_arch", "(", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Write", "an", "extra", "function", "header", "before", "the", "very", "start", "of", "the", "function", "." ]

[ "s390", "\"\\t.machinemode push\\n\"", "\"\\t.machine push\\n\"" ]

[]

[ "<s>", "void", "MOSCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "MOS", "MOS" ]

[]

[ "<s>", "unsigned", "HexagonAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "AsmOp", ",", "unsigned", "Kind", ")", "{", "HexagonOperand", "*", "Op", "=", "static_cast", "<", "HexagonOperand", "*", ">", "(", "&", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_0", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "0", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "case", "MCK_1", ":", "{", "int64_t", "Value", ";", "return", "Op", "->", "isImm", "(", ")", "&&", "Op", "->", "Imm", ".", "Val", "->", "evaluateAsAbsolute", "(", "Value", ")", "&&", "Value", "==", "1", "?", "Match_Success", ":", "Match_InvalidOperand", ";", "}", "}", "if", "(", "Op", "->", "Kind", "==", "HexagonOperand", "::", "Token", "&&", "Kind", "!=", "InvalidMatchClass", ")", "{", "StringRef", "myStringRef", "=", "StringRef", "(", "Op", "->", "Tok", ".", "Data", ",", "Op", "->", "Tok", ".", "Length", ")", ";", "if", "(", "matchTokenString", "(", "myStringRef", ".", "lower", "(", ")", ")", "==", "(", "MatchClassKind", ")", "Kind", ")", "return", "Match_Success", ";", "if", "(", "matchTokenString", "(", "myStringRef", ".", "upper", "(", ")", ")", "==", "(", "MatchClassKind", ")", "Kind", ")", "return", "Match_Success", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Unmatched Operand:\"", ")", ";", "DEBUG", "(", "Op", "->", "dump", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "1", "Hexagon", "\"Unmatched Operand:\"", "\"\\n\"" ]

[]

[ "<s>", "bool", "mips_split_128bit_move_p", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "if", "(", "FP_REG_RTX_P", "(", "src", ")", "&&", "FP_REG_RTX_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "&&", "MEM_P", "(", "src", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "src", ")", "&&", "MEM_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "&&", "mips_const_vector_same_int_p", "(", "src", ",", "GET_MODE", "(", "src", ")", ",", "-", "512", ",", "511", ")", ")", "return", "false", ";", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "&&", "src", "==", "CONST0_RTX", "(", "GET_MODE", "(", "src", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "128-bit", "move", "from", "SRC", "to", "DEST", "should", "be", "split", "." ]

[ "mips", "512", "511" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "SDValue", "BasePtr", "=", "cast", "<", "LoadSDNode", ">", "(", "Load", ")", "->", "getBasePtr", "(", ")", ";", "if", "(", "BasePtr", ".", "getOpcode", "(", ")", "==", "X86ISD", "::", "WrapperRIP", ")", "if", "(", "const", "auto", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "BasePtr", ".", "getOperand", "(", "0", ")", ")", ")", "return", "GA", "->", "getTargetFlags", "(", ")", "!=", "X86II", "::", "MO_GOTTPOFF", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "X86", "X86", "ISD::LoadExtType", "X86ISD::WrapperRIP", "0", "X86II::MO_GOTTPOFF" ]

[]

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

[ "Return", "the", "preferred", "prefetch", "distance", "in", "terms", "of", "instructions", "." ]

[ "SystemZ", "2000" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addInstSelector", "(", ")", "{", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonOptimizeSZextends", "(", ")", ")", ";", "addPass", "(", "createHexagonISelDag", "(", "TM", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "EnableGenPred", ")", "addPass", "(", "createHexagonGenPredicate", "(", ")", ")", ";", "if", "(", "EnableLoopResched", ")", "addPass", "(", "createHexagonLoopRescheduling", "(", ")", ")", ";", "if", "(", "!", "DisableHSDR", ")", "addPass", "(", "createHexagonSplitDoubleRegs", "(", ")", ")", ";", "if", "(", "EnableBitSimplify", ")", "addPass", "(", "createHexagonBitSimplify", "(", ")", ")", ";", "addPass", "(", "createHexagonPeephole", "(", ")", ")", ";", "printAndVerify", "(", "\"After hexagon peephole pass\"", ")", ";", "if", "(", "!", "DisableHCP", ")", "{", "addPass", "(", "createHexagonConstPropagationPass", "(", ")", ")", ";", "addPass", "(", "&", "UnreachableMachineBlockElimID", ")", ";", "}", "if", "(", "EnableGenInsert", ")", "addPass", "(", "createHexagonGenInsert", "(", ")", ")", ";", "if", "(", "EnableEarlyIf", ")", "addPass", "(", "createHexagonEarlyIfConversion", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"After hexagon peephole pass\"", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "void", "reorg_emit_nops", "(", "rtx_code_label", "*", "*", "call_labels", ")", "{", "bool", "first", ";", "rtx", "last_call", ";", "rtx_insn", "*", "prev", ";", "int", "prev_clock", ",", "earliest_bb_end", ";", "int", "prev_implicit_nops", ";", "rtx_insn", "*", "insn", "=", "get_insns", "(", ")", ";", "insn", "=", "next_real_insn", "(", "insn", ")", ";", "last_call", "=", "prev", "=", "NULL", ";", "prev_clock", "=", "-", "1", ";", "earliest_bb_end", "=", "0", ";", "prev_implicit_nops", "=", "0", ";", "first", "=", "true", ";", "while", "(", "insn", ")", "{", "int", "this_clock", "=", "-", "1", ";", "rtx_insn", "*", "next", ";", "int", "max_cycles", "=", "0", ";", "next", "=", "next_real_insn", "(", "insn", ")", ";", "if", "(", "DEBUG_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "CLOBBER", "||", "shadow_or_blockage_p", "(", "insn", ")", "||", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "goto", "next_insn", ";", "if", "(", "!", "c6x_flag_schedule_insns2", ")", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "else", "{", "int", "cycles", ";", "this_clock", "=", "insn_get_clock", "(", "insn", ")", ";", "if", "(", "this_clock", "!=", "prev_clock", ")", "{", "PUT_MODE", "(", "insn", ",", "TImode", ")", ";", "if", "(", "!", "first", ")", "{", "cycles", "=", "this_clock", "-", "prev_clock", ";", "cycles", "-=", "prev_implicit_nops", ";", "if", "(", "cycles", ">", "1", ")", "{", "rtx", "nop", "=", "emit_nop_after", "(", "cycles", "-", "1", ",", "prev", ")", ";", "insn_set_clock", "(", "nop", ",", "prev_clock", "+", "prev_implicit_nops", "+", "1", ")", ";", "}", "}", "prev_clock", "=", "this_clock", ";", "if", "(", "last_call", "&&", "insn_get_clock", "(", "last_call", ")", "+", "6", "<=", "this_clock", ")", "{", "emit_label_before", "(", "call_labels", "[", "INSN_UID", "(", "last_call", ")", "]", ",", "insn", ")", ";", "last_call", "=", "NULL_RTX", ";", "}", "prev_implicit_nops", "=", "0", ";", "}", "}", "if", "(", "recog_memoized", "(", "insn", ")", ">=", "0", "&&", "(", "c6x_flag_schedule_insns2", "||", "!", "returning_call_p", "(", "insn", ")", ")", ")", "{", "max_cycles", "=", "get_attr_cycles", "(", "insn", ")", ";", "if", "(", "get_attr_type", "(", "insn", ")", "==", "TYPE_CALLP", ")", "prev_implicit_nops", "=", "5", ";", "}", "else", "max_cycles", "=", "1", ";", "if", "(", "returning_call_p", "(", "insn", ")", ")", "last_call", "=", "insn", ";", "if", "(", "c6x_flag_schedule_insns2", ")", "{", "gcc_assert", "(", "this_clock", ">=", "0", ")", ";", "if", "(", "earliest_bb_end", "<", "this_clock", "+", "max_cycles", ")", "earliest_bb_end", "=", "this_clock", "+", "max_cycles", ";", "}", "else", "if", "(", "max_cycles", ">", "1", ")", "emit_nop_after", "(", "max_cycles", "-", "1", ",", "insn", ")", ";", "prev", "=", "insn", ";", "first", "=", "false", ";", "next_insn", ":", "if", "(", "c6x_flag_schedule_insns2", "&&", "(", "next", "==", "NULL_RTX", "||", "(", "GET_MODE", "(", "next", ")", "==", "TImode", "&&", "INSN_INFO_ENTRY", "(", "INSN_UID", "(", "next", ")", ")", ".", "ebb_start", ")", ")", "&&", "earliest_bb_end", ">", "0", ")", "{", "int", "cycles", "=", "earliest_bb_end", "-", "prev_clock", ";", "if", "(", "cycles", ">", "1", ")", "{", "prev", "=", "emit_nop_after", "(", "cycles", "-", "1", ",", "prev", ")", ";", "insn_set_clock", "(", "prev", ",", "prev_clock", "+", "prev_implicit_nops", "+", "1", ")", ";", "}", "earliest_bb_end", "=", "0", ";", "prev_clock", "=", "-", "1", ";", "first", "=", "true", ";", "if", "(", "last_call", ")", "emit_label_after", "(", "call_labels", "[", "INSN_UID", "(", "last_call", ")", "]", ",", "prev", ")", ";", "last_call", "=", "NULL_RTX", ";", "}", "insn", "=", "next", ";", "}", "}", "</s>" ]

[ "Called", "as", "part", "of", "c6x_reorg", ".", "This", "function", "emits", "multi-cycle", "NOP", "insns", "as", "required", "for", "correctness", ".", "CALL_LABELS", "is", "the", "array", "that", "holds", "the", "return", "labels", "for", "call", "insns", ";", "we", "emit", "these", "here", "if", "scheduling", "was", "run", "earlier", "." ]

[ "c6x", "1", "0", "0", "1", "0", "1", "1", "1", "6", "0", "0", "5", "1", "0", "1", "1", "0", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "aarch64_extr_rtx_p", "(", "rtx", "x", ",", "rtx", "*", "res_op0", ",", "rtx", "*", "res_op1", ")", "{", "rtx", "op0", ",", "op1", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "*", "res_op0", "=", "NULL_RTX", ";", "*", "res_op1", "=", "NULL_RTX", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "IOR", ")", "return", "false", ";", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "op0", ")", "==", "ASHIFT", "&&", "GET_CODE", "(", "op1", ")", "==", "LSHIFTRT", ")", "||", "(", "GET_CODE", "(", "op1", ")", "==", "ASHIFT", "&&", "GET_CODE", "(", "op0", ")", "==", "LSHIFTRT", ")", ")", "{", "if", "(", "GET_CODE", "(", "op1", ")", "==", "ASHIFT", ")", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "op0", ",", "1", ")", ")", "||", "!", "CONST_INT_P", "(", "XEXP", "(", "op1", ",", "1", ")", ")", ")", "return", "false", ";", "unsigned", "HOST_WIDE_INT", "shft_amnt_0", "=", "UINTVAL", "(", "XEXP", "(", "op0", ",", "1", ")", ")", ";", "unsigned", "HOST_WIDE_INT", "shft_amnt_1", "=", "UINTVAL", "(", "XEXP", "(", "op1", ",", "1", ")", ")", ";", "if", "(", "shft_amnt_0", "<", "GET_MODE_BITSIZE", "(", "mode", ")", "&&", "shft_amnt_0", "+", "shft_amnt_1", "==", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "{", "*", "res_op0", "=", "XEXP", "(", "op0", ",", "0", ")", ";", "*", "res_op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "X", "is", "an", "rtx", "that", "will", "match", "an", "extr", "instruction", "i.e", ".", "as", "described", "in", "the", "*", "extr", "<", "mode", ">", "5_insn", "family", "of", "patterns", ".", "OP0", "and", "OP1", "will", "be", "set", "to", "the", "operands", "of", "the", "shifts", "involved", "on", "success", "and", "will", "be", "NULL_RTX", "otherwise", "." ]

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

[]

[ "<s>", "void", "mips_expand_vec_reduc", "(", "rtx", "target", ",", "rtx", "in", ",", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "in", ")", ";", "unsigned", "char", "perm2", "[", "2", "]", ";", "rtx", "last", ",", "next", ",", "fold", ",", "x", ";", "bool", "ok", ";", "last", "=", "in", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "switch", "(", "vmode", ")", "{", "case", "V2SFmode", ":", "perm2", "[", "0", "]", "=", "1", ";", "perm2", "[", "1", "]", "=", "2", ";", "ok", "=", "mips_expand_vselect_vconcat", "(", "fold", ",", "last", ",", "last", ",", "perm2", ",", "2", ")", ";", "gcc_assert", "(", "ok", ")", ";", "break", ";", "case", "V2SImode", ":", "emit_insn", "(", "gen_loongson_punpckhwd", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "break", ";", "case", "V4HImode", ":", "emit_insn", "(", "gen_loongson_punpckhwd_hi", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "next", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_insn", "(", "gen", "(", "next", ",", "last", ",", "fold", ")", ")", ";", "last", "=", "next", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "x", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "16", ")", ")", ";", "emit_insn", "(", "gen_vec_shr_v4hi", "(", "fold", ",", "last", ",", "x", ")", ")", ";", "break", ";", "case", "V8QImode", ":", "emit_insn", "(", "gen_loongson_punpckhwd_qi", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "next", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_insn", "(", "gen", "(", "next", ",", "last", ",", "fold", ")", ")", ";", "last", "=", "next", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "x", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "16", ")", ")", ";", "emit_insn", "(", "gen_vec_shr_v8qi", "(", "fold", ",", "last", ",", "x", ")", ")", ";", "next", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "emit_insn", "(", "gen", "(", "next", ",", "last", ",", "fold", ")", ")", ";", "last", "=", "next", ";", "fold", "=", "gen_reg_rtx", "(", "vmode", ")", ";", "x", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "8", ")", ")", ";", "emit_insn", "(", "gen_vec_shr_v8qi", "(", "fold", ",", "last", ",", "x", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "target", ",", "last", ",", "fold", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "reduction", "." ]

[ "mips", "2", "0", "1", "1", "2", "2", "16", "16", "8" ]

[]

[ "<s>", "static", "rtx", "move_to_acc", "(", "int", "opno", ",", "rtx_insn", "*", "before", ")", "{", "rtx", "src", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "if", "(", "REG_P", "(", "src", ")", "&&", "REGNO", "(", "src", ")", "<", "2", ")", "return", "src", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "recog_data", ".", "operand_mode", "[", "opno", "]", ";", "return", "gen_and_emit_move", "(", "mode", "==", "QImode", "?", "A", ":", "AX", ",", "src", ",", "before", ",", "true", ")", ";", "}", "</s>" ]

[ "Copy", "SRC", "to", "accumulator", "(", "A", "or", "AX", ")", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "accumulator", "RTX", "." ]

[ "rl78", "2" ]

[]

[ "<s>", "void", "maybe_unlink", "(", "const", "char", "*", "file", ")", "{", "if", "(", "!", "save_temps", ")", "{", "if", "(", "unlink_if_ordinary", "(", "file", ")", "&&", "errno", "!=", "ENOENT", ")", "fatal_error", "(", "input_location", ",", "\"deleting file %s: %m\"", ",", "file", ")", ";", "}", "else", "if", "(", "verbose", ")", "fprintf", "(", "stderr", ",", "\"[Leaving %s]\\n\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Unlink", "a", "temporary", "file", "unless", "requested", "otherwise", "." ]

[ "i386", "\"deleting file %s: %m\"", "\"[Leaving %s]\\n\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", "||", "isNewValueJump", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "||", "isEndLoopN", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCannot predicate:\"", ";", "MI", ".", "dump", "(", ")", ";", ")", ";", "return", "false", ";", "}", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "bool", "invertJump", "=", "predOpcodeHasNot", "(", "Cond", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "PredOpc", "=", "getCondOpcode", "(", "Opc", ",", "invertJump", ")", ";", "MachineInstrBuilder", "T", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "get", "(", "PredOpc", ")", ")", ";", "unsigned", "NOp", "=", "0", ",", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "NOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "break", ";", "T", ".", "add", "(", "Op", ")", ";", "NOp", "++", ";", "}", "unsigned", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ";", "bool", "GotPredReg", "=", "getPredReg", "(", "Cond", ",", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ")", ";", "(", "void", ")", "GotPredReg", ";", "assert", "(", "GotPredReg", ")", ";", "T", ".", "addReg", "(", "PredReg", ",", "PredRegFlags", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "T", ".", "add", "(", "MI", ".", "getOperand", "(", "NOp", "++", ")", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "PredOpc", ")", ")", ";", "while", "(", "unsigned", "n", "=", "MI", ".", "getNumOperands", "(", ")", ")", "MI", ".", "removeOperand", "(", "n", "-", "1", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "T", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "MI", ".", "addOperand", "(", "T", "->", "getOperand", "(", "i", ")", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "TI", "=", "T", "->", "getIterator", "(", ")", ";", "B", ".", "erase", "(", "TI", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "B", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "clearKillFlags", "(", "PredReg", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "0", "\"\\nCannot predicate:\"", "\"Expected predicable instruction\"", "0", "1", "0" ]

[]

[ "<s>", "static", "rtx", "arm_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "libcall", ")", "{", "if", "(", "TARGET_AAPCS_BASED", "&&", "arm_pcs_default", "!=", "ARM_PCS_AAPCS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "{", "if", "(", "arm_libcall_uses_aapcs_base", "(", "libcall", ")", ")", "return", "gen_rtx_REG", "(", "mode", ",", "ARG_REGISTER", "(", "1", ")", ")", ";", "}", "return", "arm_libcall_value_1", "(", "mode", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "library", "function", "assuming", "the", "value", "has", "mode", "MODE", "." ]

[ "arm", "1" ]

[]

[ "<s>", "SDValue", "SystemZTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_SystemZ", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "SDValue", "ResValue", "=", "Outs", "[", "i", "]", ".", "Val", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", ")", "ResValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "ResValue", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "ResValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "ResValue", ")", ";", "else", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "AExt", ")", "ResValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "ResValue", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "ResValue", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "SystemZISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "ISD::OutputArg", "16", "SystemZ", "0", "0", "\"Can only return in registers!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "1", "SystemZISD::RET_FLAG", "MVT::Other", "SystemZISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "InstructionCost", "ARMTTIImpl", "::", "getIntImmCodeSizeCost", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "{", "if", "(", "Imm", ".", "isNonNegative", "(", ")", "&&", "Imm", ".", "getLimitedValue", "(", ")", "<", "256", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "for", "the", "given", "integer", "when", "optimising", "for", "size", "." ]

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

[]

[ "<s>", "ARMSubtarget", "::", "ARMSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "ARMBaseTargetMachine", "&", "TM", ",", "bool", "IsLittle", ",", "bool", "MinSize", ")", ":", "ARMGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "UseMulOps", "(", "UseFusedMulOps", ")", ",", "CPUString", "(", "CPU", ")", ",", "OptMinSize", "(", "MinSize", ")", ",", "IsLittle", "(", "IsLittle", ")", ",", "TargetTriple", "(", "TT", ")", ",", "Options", "(", "TM", ".", "Options", ")", ",", "TM", "(", "TM", ")", ",", "FrameLowering", "(", "initializeFrameLowering", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "isThumb1Only", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb1InstrInfo", "(", "*", "this", ")", ":", "!", "isThumb", "(", ")", "?", "(", "ARMBaseInstrInfo", "*", ")", "new", "ARMInstrInfo", "(", "*", "this", ")", ":", "(", "ARMBaseInstrInfo", "*", ")", "new", "Thumb2InstrInfo", "(", "*", "this", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "CallLoweringInfo", ".", "reset", "(", "new", "ARMCallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "ARMLegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "ARMRegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createARMInstructionSelector", "(", "*", "static_cast", "<", "const", "ARMBaseTargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MBlazeTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createMBlazeDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "arm_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "int", "skip", ";", "while", "(", "(", "skip", "=", "arm_get_strip_length", "(", "*", "name", ")", ")", ")", "name", "+=", "skip", ";", "return", "name", ";", "}", "</s>" ]

[ "Return", "a", "pointer", "to", "a", "function", "'s", "name", "with", "any", "and", "all", "prefix", "encodings", "stripped", "from", "it", "." ]

[ "arm" ]

[]

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

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

[ "ARM64" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "keepFramePointer", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "useFastISel", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "wants", "to", "keep", "the", "frame", "pointer", "regardless", "of", "the", "function", "attribute", "``", "frame-pointer", "''", "." ]

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

[]

[ "<s>", "bool", "VZeroUpperInserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasAVX", "(", ")", "||", "ST", ".", "hasAVX512", "(", ")", ")", "return", "false", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "EverMadeChange", "=", "false", ";", "bool", "YMMUsed", "=", "false", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "X86", "::", "VR256RegClass", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "i", "=", "RC", "->", "begin", "(", ")", ",", "e", "=", "RC", "->", "end", "(", ")", ";", "i", "!=", "e", ";", "i", "++", ")", "{", "if", "(", "!", "MRI", ".", "reg_nodbg_empty", "(", "*", "i", ")", ")", "{", "YMMUsed", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "YMMUsed", ")", "{", "return", "false", ";", "}", "assert", "(", "BlockStates", ".", "empty", "(", ")", "&&", "DirtySuccessors", ".", "empty", "(", ")", "&&", "\"X86VZeroUpper state should be clear\"", ")", ";", "BlockStates", ".", "resize", "(", "MF", ".", "getNumBlockIDs", "(", ")", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "processBasicBlock", "(", "*", "I", ")", ";", "if", "(", "checkFnHasLiveInYmm", "(", "MRI", ")", ")", "addDirtySuccessor", "(", "MF", ".", "front", "(", ")", ")", ";", "while", "(", "!", "DirtySuccessors", ".", "empty", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "DirtySuccessors", ".", "back", "(", ")", ";", "DirtySuccessors", ".", "pop_back", "(", ")", ";", "BlockState", "&", "BBState", "=", "BlockStates", "[", "MBB", ".", "getNumber", "(", ")", "]", ";", "if", "(", "BBState", ".", "FirstUnguardedCall", "!=", "MBB", ".", "end", "(", ")", ")", "insertVZeroUpper", "(", "BBState", ".", "FirstUnguardedCall", ",", "MBB", ")", ";", "if", "(", "BBState", ".", "ExitState", "==", "PASS_THROUGH", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"MBB #\"", "<<", "MBB", ".", "getNumber", "(", ")", "<<", "\" was Pass-through, is now Dirty-out.\\n\"", ")", ";", "for", "(", "MachineBasicBlock", "::", "succ_iterator", "SI", "=", "MBB", ".", "succ_begin", "(", ")", ",", "SE", "=", "MBB", ".", "succ_end", "(", ")", ";", "SI", "!=", "SE", ";", "++", "SI", ")", "addDirtySuccessor", "(", "*", "*", "SI", ")", ";", "}", "}", "BlockStates", ".", "clear", "(", ")", ";", "return", "EverMadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::VR256RegClass", "\"X86VZeroUpper state should be clear\"", "\"MBB #\"", "\" was Pass-through, is now Dirty-out.\\n\"" ]

[]

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

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

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

[]

[ "<s>", "static", "e_funkind", "funkind", "(", "tree", "funtype", ")", "{", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "funtype", ")", ";", "if", "(", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "attrs", ")", ")", "return", "INTERRUPT_HANDLER", ";", "else", "if", "(", "lookup_attribute", "(", "\"exception_handler\"", ",", "attrs", ")", ")", "return", "EXCPT_HANDLER", ";", "else", "if", "(", "lookup_attribute", "(", "\"nmi_handler\"", ",", "attrs", ")", ")", "return", "NMI_HANDLER", ";", "else", "return", "SUBROUTINE", ";", "}", "</s>" ]

[ "Examine", "machine-dependent", "attributes", "of", "function", "type", "FUNTYPE", "and", "return", "its", "type", ".", "See", "the", "definition", "of", "E_FUNKIND", "." ]

[ "bfin", "\"interrupt_handler\"", "\"exception_handler\"", "\"nmi_handler\"" ]

[]

[ "<s>", "unsigned", "int", "vectors_per_tuple", "(", ")", "const", "OVERRIDE", "{", "return", "m_vectors_per_tuple", ";", "}", "</s>" ]

[ "If", "the", "function", "operates", "on", "tuples", "of", "vectors", ",", "return", "the", "number", "of", "vectors", "in", "the", "tuples", ",", "otherwise", "return", "1", "." ]

[ "aarch64" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "const", "ARMSubtarget", "&", "Subtarget", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isAAPCS_ABI", "(", ")", "||", "Subtarget", ".", "isTargetMachO", "(", ")", "||", "Subtarget", ".", "isTargetWindows", "(", ")", ")", "return", "SDValue", "(", ")", ";", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "Subtarget", ".", "getTargetLowering", "(", ")", ";", "TargetLowering", "::", "ArgListTy", "Args", ";", "TargetLowering", "::", "ArgListEntry", "Entry", ";", "Type", "*", "IntPtrTy", "=", "TLI", ".", "getDataLayout", "(", ")", "->", "getIntPtrType", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "Node", "=", "Dst", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "Entry", ".", "Node", "=", "Size", ";", "Entry", ".", "Ty", "=", "IntPtrTy", ";", "Entry", ".", "isSExt", "=", "false", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", ".", "bitsGT", "(", "MVT", "::", "i32", ")", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "else", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "Entry", ".", "Node", "=", "Src", ";", "Entry", ".", "Ty", "=", "Type", "::", "getInt32Ty", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "Entry", ".", "isSExt", "=", "true", ";", "Args", ".", "push_back", "(", "Entry", ")", ";", "TargetLowering", "::", "CallLoweringInfo", "CLI", "(", "DAG", ")", ";", "CLI", ".", "setDebugLoc", "(", "dl", ")", ".", "setChain", "(", "Chain", ")", ".", "setCallee", "(", "TLI", ".", "getLibcallCallingConv", "(", "RTLIB", "::", "MEMSET", ")", ",", "Type", "::", "getVoidTy", "(", "*", "DAG", ".", "getContext", "(", ")", ")", ",", "DAG", ".", "getExternalSymbol", "(", "TLI", ".", "getLibcallName", "(", "RTLIB", "::", "MEMSET", ")", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ",", "std", "::", "move", "(", "Args", ")", ",", "0", ")", ".", "setDiscardResult", "(", ")", ";", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "CallResult", "=", "TLI", ".", "LowerCallTo", "(", "CLI", ")", ";", "return", "CallResult", ".", "second", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "MVT::i32", "ISD::TRUNCATE", "MVT::i32", "ISD::ZERO_EXTEND", "MVT::i32", "0" ]

[]

[ "<s>", "int", "valid_mov3q_const", "(", "rtx", "constant", ")", "{", "int", "i", ";", "if", "(", "TARGET_CFV4", "&&", "GET_CODE", "(", "constant", ")", "==", "CONST_INT", ")", "{", "i", "=", "INTVAL", "(", "constant", ")", ";", "if", "(", "(", "i", "==", "-", "1", ")", "||", "(", "i", ">=", "1", "&&", "i", "<=", "7", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "'constant", "'", "can", "be", "represented", "by", "mov3q", "on", "a", "ColdFire", "V4", "core", "." ]

[ "m68k", "1", "1", "7", "1", "0" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "(", "NumBytes", "-", "i", "-", "1", ")", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "0", "1", "8", "0xff" ]

[]

[ "<s>", "unsigned", "HexagonMCCodeEmitter", "::", "getMachineOpValue", "(", "MCInst", "const", "&", "MI", ",", "MCOperand", "const", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "MCSubtargetInfo", "const", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MCT", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Only Immediates and Registers implemented right now\"", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Hexagon", "Hexagon", "\"Only Immediates and Registers implemented right now\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "useLoadStackGuardNode", "(", ")", "const", "{", "return", "Subtarget", "->", "isTargetMachO", "(", ")", "&&", "Subtarget", "->", "is64Bit", "(", ")", ";", "}", "</s>" ]

[ "If", "this", "function", "returns", "true", ",", "SelectionDAGBuilder", "emits", "a", "LOAD_STACK_GUARD", "node", "when", "it", "is", "lowering", "Intrinsic", ":", ":stackprotector", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "HexagonRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "HexagonSubtarget", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "if", "(", "!", "HST", ".", "useHVXOps", "(", ")", "||", "NewRC", "->", "getID", "(", ")", "!=", "Hexagon", "::", "HvxWRRegClass", ".", "getID", "(", ")", ")", "return", "true", ";", "bool", "SmallSrc", "=", "SrcRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "HvxVRRegClass", ".", "getID", "(", ")", ";", "bool", "SmallDst", "=", "DstRC", "->", "getID", "(", ")", "==", "Hexagon", "::", "HvxVRRegClass", ".", "getID", "(", ")", ";", "if", "(", "!", "SmallSrc", "&&", "!", "SmallDst", ")", "return", "true", ";", "Register", "DstReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "SrcReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "const", "SlotIndexes", "&", "Indexes", "=", "*", "LIS", ".", "getSlotIndexes", "(", ")", ";", "auto", "HasCall", "=", "[", "&", "Indexes", "]", "(", "const", "LiveInterval", "::", "Segment", "&", "S", ")", "{", "for", "(", "SlotIndex", "I", "=", "S", ".", "start", ".", "getBaseIndex", "(", ")", ",", "E", "=", "S", ".", "end", ".", "getBaseIndex", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "I", ".", "getNextIndex", "(", ")", ")", "{", "if", "(", "const", "MachineInstr", "*", "MI", "=", "Indexes", ".", "getInstructionFromIndex", "(", "I", ")", ")", "if", "(", "MI", "->", "isCall", "(", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", ";", "if", "(", "SmallSrc", "==", "SmallDst", ")", "{", "return", "!", "any_of", "(", "LIS", ".", "getInterval", "(", "DstReg", ")", ",", "HasCall", ")", "&&", "!", "any_of", "(", "LIS", ".", "getInterval", "(", "SrcReg", ")", ",", "HasCall", ")", ";", "}", "unsigned", "SmallReg", "=", "SmallSrc", "?", "SrcReg", ":", "DstReg", ";", "unsigned", "LargeReg", "=", "SmallSrc", "?", "DstReg", ":", "SrcReg", ";", "return", "any_of", "(", "LIS", ".", "getInterval", "(", "LargeReg", ")", ",", "HasCall", ")", "||", "!", "any_of", "(", "LIS", ".", "getInterval", "(", "SmallReg", ")", ",", "HasCall", ")", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::HvxWRRegClass", "Hexagon::HvxVRRegClass", "Hexagon::HvxVRRegClass", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "output_a_rotate", "(", "enum", "rtx_code", "code", ",", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "rotate_amount", "=", "operands", "[", "2", "]", ";", "enum", "shift_mode", "rotate_mode", ";", "enum", "shift_type", "rotate_type", ";", "const", "char", "*", "insn_buf", ";", "int", "bits", ";", "int", "amount", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "rotate_amount", ")", "==", "CONST_INT", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "rotate_mode", "=", "QIshift", ";", "break", ";", "case", "E_HImode", ":", "rotate_mode", "=", "HIshift", ";", "break", ";", "case", "E_SImode", ":", "rotate_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ROTATERT", ":", "rotate_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "case", "ROTATE", ":", "rotate_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "amount", "=", "INTVAL", "(", "rotate_amount", ")", ";", "if", "(", "amount", "<", "0", ")", "amount", "=", "0", ";", "if", "(", "(", "unsigned", "int", ")", "amount", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "if", "(", "(", "unsigned", "int", ")", "amount", ">", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "(", "unsigned", ")", "2", ")", "{", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "amount", ";", "rotate_type", "=", "(", "rotate_type", "==", "SHIFT_ASHIFT", ")", "?", "SHIFT_LSHIFTRT", ":", "SHIFT_ASHIFT", ";", "}", "if", "(", "(", "mode", "==", "HImode", "&&", "TARGET_H8300H", "&&", "amount", ">=", "6", ")", "||", "(", "mode", "==", "HImode", "&&", "TARGET_H8300S", "&&", "amount", "==", "8", ")", "||", "(", "mode", "==", "SImode", "&&", "TARGET_H8300H", "&&", "amount", ">=", "10", ")", "||", "(", "mode", "==", "SImode", "&&", "TARGET_H8300S", "&&", "amount", ">=", "13", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "insn_buf", "=", "\"xor.b\\t%s0,%t0\\n\\txor.b\\t%t0,%s0\\n\\txor.b\\t%s0,%t0\"", ";", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "break", ";", "case", "E_SImode", ":", "insn_buf", "=", "\"xor.w\\t%e0,%f0\\n\\txor.w\\t%f0,%e0\\n\\txor.w\\t%e0,%f0\"", ";", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "amount", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "2", "-", "amount", ";", "rotate_type", "=", "(", "rotate_type", "==", "SHIFT_ASHIFT", ")", "?", "SHIFT_LSHIFTRT", ":", "SHIFT_ASHIFT", ";", "}", "for", "(", "bits", "=", "TARGET_H8300S", "?", "2", ":", "1", ";", "bits", ">", "0", ";", "bits", "/=", "2", ")", "{", "if", "(", "bits", "==", "2", ")", "insn_buf", "=", "rotate_two", "[", "rotate_type", "]", "[", "rotate_mode", "]", ";", "else", "insn_buf", "=", "rotate_one", "[", "cpu_type", "]", "[", "rotate_type", "]", "[", "rotate_mode", "]", ";", "for", "(", ";", "amount", ">=", "bits", ";", "amount", "-=", "bits", ")", "output_asm_insn", "(", "insn_buf", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "rotate", "insn", "." ]

[ "h8300", "0", "2", "0", "0", "2", "6", "8", "10", "13", "\"xor.b\\t%s0,%t0\\n\\txor.b\\t%t0,%s0\\n\\txor.b\\t%s0,%t0\"", "\"xor.w\\t%e0,%f0\\n\\txor.w\\t%f0,%e0\\n\\txor.w\\t%e0,%f0\"", "2", "2", "1", "0", "2", "2", "\"\"" ]

[]

[ "<s>", "rtx", "function_expander", "::", "use_contiguous_store_insn", "(", "insn_code", "icode", ")", "{", "machine_mode", "mem_mode", "=", "memory_vector_mode", "(", ")", ";", "add_mem_operand", "(", "mem_mode", ",", "get_contiguous_base", "(", "mem_mode", ")", ")", ";", "add_input_operand", "(", "icode", ",", "args", ".", "last", "(", ")", ")", ";", "add_input_operand", "(", "icode", ",", "args", "[", "0", "]", ")", ";", "return", "generate_insn", "(", "icode", ")", ";", "}", "</s>" ]

[ "Use", "contiguous", "store", "INSN", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "void", "OrderedRegisterList", "::", "insert", "(", "unsigned", "VR", ")", "{", "iterator", "L", "=", "std", "::", "lower_bound", "(", "Seq", ".", "begin", "(", ")", ",", "Seq", ".", "end", "(", ")", ",", "VR", ",", "Ord", ")", ";", "if", "(", "L", "==", "Seq", ".", "end", "(", ")", ")", "Seq", ".", "push_back", "(", "VR", ")", ";", "else", "Seq", ".", "insert", "(", "L", ",", "VR", ")", ";", "unsigned", "S", "=", "Seq", ".", "size", "(", ")", ";", "if", "(", "S", ">", "MaxSize", ")", "Seq", ".", "resize", "(", "MaxSize", ")", ";", "assert", "(", "Seq", ".", "size", "(", ")", "<=", "MaxSize", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "visium_profile_hook", "(", "void", ")", "{", "visium_frame_needed", "=", "true", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"mcount\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "0", ")", ";", "}", "</s>" ]

[ "Profiling", "support", ".", "Just", "a", "call", "to", "MCOUNT", "is", "needed", ".", "No", "labelled", "counter", "location", "is", "involved", ".", "Proper", "support", "for", "__builtin_return_address", "is", "also", "required", ",", "which", "is", "fairly", "straightforward", "provided", "a", "frame", "gets", "created", "." ]

[ "visium", "\"mcount\"", "0" ]

[]

[ "<s>", "unsigned", "HSAILTargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "return", "MachineJumpTableInfo", "::", "EK_BlockAddress", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "static", "unsigned", "int", "get_csky_live_regs", "(", "int", "*", "count", ")", "{", "int", "reg", ";", "unsigned", "int", "live_regs_mask", "=", "0", ";", "*", "count", "=", "0", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "CSKY_NGPR_REGS", ";", "reg", "++", ")", "{", "bool", "save", "=", "false", ";", "if", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "&&", "reg", ">", "8", "&&", "reg", "<", "13", ")", "continue", ";", "if", "(", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "||", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK803", ")", ")", "&&", "reg", ">", "15", ")", "break", ";", "if", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "!", "call_used_regs", "[", "reg", "]", ")", "save", "=", "true", ";", "else", "if", "(", "frame_pointer_needed", "&&", "reg", "==", "HARD_FRAME_POINTER_REGNUM", ")", "save", "=", "true", ";", "else", "if", "(", "crtl", "->", "calls_eh_return", "&&", "reg", "==", "HARD_FRAME_POINTER_REGNUM", ")", "save", "=", "true", ";", "else", "if", "(", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "||", "CSKY_TARGET_ARCH", "(", "CK802", ")", ")", "&&", "reg", "==", "CSKY_LR_REGNUM", "&&", "(", "!", "crtl", "->", "is_leaf", "||", "csky_far_jump_used_p", "(", ")", ")", ")", "save", "=", "true", ";", "else", "if", "(", "crtl", "->", "calls_eh_return", "&&", "reg", ">=", "CSKY_FIRST_EH_RETDATA_REGNUM", "&&", "reg", "<=", "CSKY_LAST_EH_RETDATA_REGNUM", ")", "save", "=", "true", ";", "if", "(", "reg", "==", "CSKY_STACKADJUST_REGNUM", "&&", "cfun", "->", "machine", "->", "reg_offset", ">", "CSKY_MAX_SP_ADJUST", "*", "2", ")", "save", "=", "true", ";", "if", "(", "save", ")", "{", "(", "*", "count", ")", "++", ";", "live_regs_mask", "|=", "(", "1", "<<", "reg", ")", ";", "}", "}", "return", "live_regs_mask", ";", "}", "</s>" ]

[ "Return", "the", "mask", "of", "registers", "used", "by", "the", "current", "function", ".", "Set", "COUNT", "to", "the", "number", "of", "registers", "used", "." ]

[ "csky", "0", "0", "0", "8", "13", "15", "2", "1" ]

[]

[ "<s>", "static", "int", "get_some_local_dynamic_name_1", "(", "rtx", "*", "px", ",", "void", "*", "data", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "x", "=", "*", "px", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "{", "cfun", "->", "machine", "->", "some_ld_name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "See", "'get_some_local_dynamic_name", "'", "." ]

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

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "uint16_t", "*", "Dst", "=", "(", "uint16_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", ";", "*", "Dst", "=", "(", "Value", "-", "4", ")", "/", "4", ";", "}", "</s>" ]

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

[ "R600", "4", "4" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "assert", "(", "BranchOp", "!=", "AMDGPU", "::", "S_SETPC_B64", ")", ";", "BrOffset", "/=", "4", ";", "BrOffset", "-=", "1", ";", "return", "isIntN", "(", "BranchOffsetBits", ",", "BrOffset", ")", ";", "}", "</s>" ]

[ "Determine", "if", "the", "branch", "target", "is", "in", "range", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_SETPC_B64", "4", "1" ]

[]

[ "<s>", "static", "int", "ix86_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", ")", "{", "bool", "fp", "=", "false", ";", "machine_mode", "mode", "=", "TImode", ";", "int", "index", ";", "if", "(", "vectype", "!=", "NULL", ")", "{", "fp", "=", "FLOAT_TYPE_P", "(", "vectype", ")", ";", "mode", "=", "TYPE_MODE", "(", "vectype", ")", ";", "}", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "return", "fp", "?", "ix86_cost", "->", "addss", ":", "COSTS_N_INSNS", "(", "1", ")", ";", "case", "scalar_load", ":", "return", "COSTS_N_INSNS", "(", "fp", "?", "ix86_cost", "->", "sse_load", "[", "0", "]", ":", "ix86_cost", "->", "int_load", "[", "2", "]", ")", "/", "2", ";", "case", "scalar_store", ":", "return", "COSTS_N_INSNS", "(", "fp", "?", "ix86_cost", "->", "sse_store", "[", "0", "]", ":", "ix86_cost", "->", "int_store", "[", "2", "]", ")", "/", "2", ";", "case", "vector_stmt", ":", "return", "ix86_vec_cost", "(", "mode", ",", "fp", "?", "ix86_cost", "->", "addss", ":", "ix86_cost", "->", "sse_op", ",", "true", ")", ";", "case", "vector_load", ":", "index", "=", "sse_store_index", "(", "mode", ")", ";", "if", "(", "index", "<", "0", ")", "index", "=", "2", ";", "return", "ix86_vec_cost", "(", "mode", ",", "COSTS_N_INSNS", "(", "ix86_cost", "->", "sse_load", "[", "index", "]", ")", "/", "2", ",", "true", ")", ";", "case", "vector_store", ":", "index", "=", "sse_store_index", "(", "mode", ")", ";", "if", "(", "index", "<", "0", ")", "index", "=", "2", ";", "return", "ix86_vec_cost", "(", "mode", ",", "COSTS_N_INSNS", "(", "ix86_cost", "->", "sse_store", "[", "index", "]", ")", "/", "2", ",", "true", ")", ";", "case", "vec_to_scalar", ":", "case", "scalar_to_vec", ":", "return", "ix86_vec_cost", "(", "mode", ",", "ix86_cost", "->", "sse_op", ",", "true", ")", ";", "case", "unaligned_load", ":", "index", "=", "sse_store_index", "(", "mode", ")", ";", "if", "(", "index", "<", "0", ")", "index", "=", "2", ";", "return", "ix86_vec_cost", "(", "mode", ",", "COSTS_N_INSNS", "(", "ix86_cost", "->", "sse_unaligned_load", "[", "index", "]", ")", "/", "2", ",", "true", ")", ";", "case", "unaligned_store", ":", "index", "=", "sse_store_index", "(", "mode", ")", ";", "if", "(", "index", "<", "0", ")", "index", "=", "2", ";", "return", "ix86_vec_cost", "(", "mode", ",", "COSTS_N_INSNS", "(", "ix86_cost", "->", "sse_unaligned_store", "[", "index", "]", ")", "/", "2", ",", "true", ")", ";", "case", "vector_gather_load", ":", "return", "ix86_vec_cost", "(", "mode", ",", "COSTS_N_INSNS", "(", "ix86_cost", "->", "gather_static", "+", "ix86_cost", "->", "gather_per_elt", "*", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ")", "/", "2", ",", "true", ")", ";", "case", "vector_scatter_store", ":", "return", "ix86_vec_cost", "(", "mode", ",", "COSTS_N_INSNS", "(", "ix86_cost", "->", "scatter_static", "+", "ix86_cost", "->", "scatter_per_elt", "*", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", ")", "/", "2", ",", "true", ")", ";", "case", "cond_branch_taken", ":", "return", "ix86_cost", "->", "cond_taken_branch_cost", ";", "case", "cond_branch_not_taken", ":", "return", "ix86_cost", "->", "cond_not_taken_branch_cost", ";", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "return", "ix86_vec_cost", "(", "mode", ",", "ix86_cost", "->", "sse_op", ",", "true", ")", ";", "case", "vec_construct", ":", "{", "int", "cost", "=", "ix86_vec_cost", "(", "mode", ",", "ix86_cost", "->", "sse_op", ",", "false", ")", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "256", ")", "cost", "+=", "ix86_vec_cost", "(", "mode", ",", "ix86_cost", "->", "addss", ",", "true", ")", ";", "else", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "512", ")", "cost", "+=", "3", "*", "ix86_vec_cost", "(", "mode", ",", "ix86_cost", "->", "addss", ",", "true", ")", ";", "return", "cost", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "NVPTXInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "DestReg", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "SrcReg", ")", ";", "if", "(", "RegInfo", ".", "getRegSizeInBits", "(", "*", "DestRC", ")", "!=", "RegInfo", ".", "getRegSizeInBits", "(", "*", "SrcRC", ")", ")", "report_fatal_error", "(", "\"Copy one register into another with a different width\"", ")", ";", "unsigned", "Op", ";", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int1RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV1rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int16RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV16rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Int32RegsRegClass", "?", "NVPTX", "::", "IMOV32rr", ":", "NVPTX", "::", "BITCONVERT_32_F2I", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Int64RegsRegClass", "?", "NVPTX", "::", "IMOV64rr", ":", "NVPTX", "::", "BITCONVERT_64_F2I", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float16RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float16RegsRegClass", "?", "NVPTX", "::", "FMOV16rr", ":", "NVPTX", "::", "BITCONVERT_16_I2F", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float16x2RegsRegClass", ")", "{", "Op", "=", "NVPTX", "::", "IMOV32rr", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float32RegsRegClass", "?", "NVPTX", "::", "FMOV32rr", ":", "NVPTX", "::", "BITCONVERT_32_I2F", ")", ";", "}", "else", "if", "(", "DestRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", ")", "{", "Op", "=", "(", "SrcRC", "==", "&", "NVPTX", "::", "Float64RegsRegClass", "?", "NVPTX", "::", "FMOV64rr", ":", "NVPTX", "::", "BITCONVERT_64_I2F", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Bad register copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Op", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "\"Copy one register into another with a different width\"", "NVPTX::Int1RegsRegClass", "NVPTX::IMOV1rr", "NVPTX::Int16RegsRegClass", "NVPTX::IMOV16rr", "NVPTX::Int32RegsRegClass", "NVPTX::Int32RegsRegClass", "NVPTX::IMOV32rr", "NVPTX::BITCONVERT_32_F2I", "NVPTX::Int64RegsRegClass", "NVPTX::Int64RegsRegClass", "NVPTX::IMOV64rr", "NVPTX::BITCONVERT_64_F2I", "NVPTX::Float16RegsRegClass", "NVPTX::Float16RegsRegClass", "NVPTX::FMOV16rr", "NVPTX::BITCONVERT_16_I2F", "NVPTX::Float16x2RegsRegClass", "NVPTX::IMOV32rr", "NVPTX::Float32RegsRegClass", "NVPTX::Float32RegsRegClass", "NVPTX::FMOV32rr", "NVPTX::BITCONVERT_32_I2F", "NVPTX::Float64RegsRegClass", "NVPTX::Float64RegsRegClass", "NVPTX::FMOV64rr", "NVPTX::BITCONVERT_64_I2F", "\"Bad register copy\"" ]

[]

[ "<s>", "SDValue", "VECustomDAG", "::", "getLegalReductionOpVVP", "(", "unsigned", "VVPOpcode", ",", "EVT", "ResVT", ",", "SDValue", "StartV", ",", "SDValue", "VectorV", ",", "SDValue", "Mask", ",", "SDValue", "AVL", ",", "SDNodeFlags", "Flags", ")", "const", "{", "bool", "scalarizeStartParam", "=", "StartV", "&&", "!", "hasReductionStartParam", "(", "VVPOpcode", ")", ";", "bool", "IsMaskReduction", "=", "isMaskType", "(", "VectorV", ".", "getValueType", "(", ")", ")", ";", "assert", "(", "!", "IsMaskReduction", "&&", "\"TODO Implement\"", ")", ";", "auto", "AttachStartValue", "=", "[", "&", "]", "(", "SDValue", "ReductionResV", ")", "{", "if", "(", "!", "scalarizeStartParam", ")", "return", "ReductionResV", ";", "auto", "ScalarOC", "=", "getScalarReductionOpcode", "(", "VVPOpcode", ",", "IsMaskReduction", ")", ";", "return", "getNode", "(", "ScalarOC", ",", "ResVT", ",", "{", "StartV", ",", "ReductionResV", "}", ")", ";", "}", ";", "if", "(", "!", "scalarizeStartParam", "&&", "StartV", ")", "{", "assert", "(", "hasReductionStartParam", "(", "VVPOpcode", ")", ")", ";", "return", "AttachStartValue", "(", "getNode", "(", "VVPOpcode", ",", "ResVT", ",", "{", "StartV", ",", "VectorV", ",", "Mask", ",", "AVL", "}", ",", "Flags", ")", ")", ";", "}", "else", "return", "AttachStartValue", "(", "getNode", "(", "VVPOpcode", ",", "ResVT", ",", "{", "VectorV", ",", "Mask", ",", "AVL", "}", ",", "Flags", ")", ")", ";", "}", "</s>" ]

[ "}", "getNode" ]

[ "VE", "VECustomDAG::getLegalReductionOpVVP", "\"TODO Implement\"" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "isSimpleMove", "(", "MI", ",", "FrameIndex", ",", "RISCVII", "::", "SimpleLoad", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVII::SimpleLoad" ]

[]

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

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "static", "int", "rs6000_register_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "int", "ret", ";", "if", "(", "TARGET_DEBUG_COST", ")", "dbg_cost_ctrl", "++", ";", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", "||", "reg_classes_intersect_p", "(", "from", ",", "GENERAL_REGS", ")", ")", "{", "reg_class_t", "rclass", "=", "from", ";", "if", "(", "!", "reg_classes_intersect_p", "(", "to", ",", "GENERAL_REGS", ")", ")", "rclass", "=", "to", ";", "if", "(", "rclass", "==", "FLOAT_REGS", "||", "rclass", "==", "ALTIVEC_REGS", "||", "rclass", "==", "VSX_REGS", ")", "ret", "=", "(", "rs6000_memory_move_cost", "(", "mode", ",", "rclass", ",", "false", ")", "+", "rs6000_memory_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "false", ")", ")", ";", "else", "if", "(", "rclass", "==", "CR_REGS", ")", "ret", "=", "4", ";", "else", "if", "(", "(", "rs6000_tune", "==", "PROCESSOR_POWER6", "||", "rs6000_tune", "==", "PROCESSOR_POWER7", "||", "rs6000_tune", "==", "PROCESSOR_POWER8", "||", "rs6000_tune", "==", "PROCESSOR_POWER9", ")", "&&", "reg_classes_intersect_p", "(", "rclass", ",", "LINK_OR_CTR_REGS", ")", ")", "ret", "=", "6", "*", "hard_regno_nregs", "(", "0", ",", "mode", ")", ";", "else", "ret", "=", "2", "*", "hard_regno_nregs", "(", "0", ",", "mode", ")", ";", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "reg_classes_intersect_p", "(", "to", ",", "VSX_REGS", ")", "&&", "reg_classes_intersect_p", "(", "from", ",", "VSX_REGS", ")", ")", "ret", "=", "2", "*", "hard_regno_nregs", "(", "FIRST_FPR_REGNO", ",", "mode", ")", ";", "else", "if", "(", "reg_classes_intersect_p", "(", "to", ",", "from", ")", ")", "ret", "=", "(", "FLOAT128_2REG_P", "(", "mode", ")", ")", "?", "4", ":", "2", ";", "else", "ret", "=", "(", "rs6000_register_move_cost", "(", "mode", ",", "GENERAL_REGS", ",", "to", ")", "+", "rs6000_register_move_cost", "(", "mode", ",", "from", ",", "GENERAL_REGS", ")", ")", ";", "if", "(", "TARGET_DEBUG_COST", ")", "{", "if", "(", "dbg_cost_ctrl", "==", "1", ")", "fprintf", "(", "stderr", ",", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"", ",", "ret", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_class_names", "[", "from", "]", ",", "reg_class_names", "[", "to", "]", ")", ";", "dbg_cost_ctrl", "--", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "A", "C", "expression", "returning", "the", "cost", "of", "moving", "data", "from", "a", "register", "of", "class", "CLASS1", "to", "one", "of", "CLASS2", "." ]

[ "rs6000", "4", "6", "0", "2", "0", "2", "4", "2", "1", "\"rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\\n\"" ]

[]

[ "<s>", "static", "int", "iq2000_address_cost", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "addr_space_t", "as", ",", "bool", "speed", ")", "{", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "LO_SUM", ":", "return", "1", ";", "case", "LABEL_REF", ":", "return", "2", ";", "case", "CONST", ":", "{", "rtx", "offset", "=", "const0_rtx", ";", "addr", "=", "eliminate_constant_term", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "2", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "SYMBOL_REF", ")", "return", "4", ";", "if", "(", "!", "SMALL_INT", "(", "offset", ")", ")", "return", "2", ";", "}", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_FLAG", "(", "addr", ")", "?", "1", ":", "2", ";", "case", "PLUS", ":", "{", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", "&&", "GET_CODE", "(", "plus1", ")", "==", "REG", ")", "plus0", "=", "XEXP", "(", "addr", ",", "1", ")", ",", "plus1", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "return", "SMALL_INT", "(", "plus1", ")", "?", "1", ":", "2", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "case", "HIGH", ":", "case", "LO_SUM", ":", "return", "iq2000_address_cost", "(", "plus1", ",", "mode", ",", "as", ",", "speed", ")", "+", "1", ";", "default", ":", "break", ";", "}", "}", "default", ":", "break", ";", "}", "return", "4", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", "." ]

[ "iq2000", "1", "2", "0", "2", "4", "2", "1", "2", "0", "1", "1", "0", "1", "2", "1", "4" ]

[]

[ "<s>", "const", "char", "*", "pa_output_mul_insn", "(", "int", "unsignedp", "ATTRIBUTE_UNUSED", ",", "rtx_insn", "*", "insn", ")", "{", "import_milli", "(", "mulI", ")", ";", "return", "pa_output_millicode_call", "(", "insn", ",", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"$$mulI\"", ")", ")", ";", "}", "</s>" ]

[ "The", "register", "constraints", "have", "put", "the", "operands", "and", "return", "value", "in", "the", "proper", "registers", "." ]

[ "pa", "\"$$mulI\"" ]

[]

[ "<s>", "void", "push", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "Set", ".", "insert", "(", "MI", ")", ".", "second", ")", "Uses", ".", "push", "(", "MI", ")", ";", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "loongarch_function_value_1", "(", "const_tree", "type", ",", "const_tree", "func", ",", "machine_mode", "mode", ")", "{", "struct", "loongarch_arg_info", "info", ";", "CUMULATIVE_ARGS", "args", ";", "if", "(", "type", ")", "{", "int", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "mode", "=", "promote_function_mode", "(", "type", ",", "mode", ",", "&", "unsigned_p", ",", "func", ",", "1", ")", ";", "}", "memset", "(", "&", "args", ",", "0", ",", "sizeof", "(", "args", ")", ")", ";", "return", "loongarch_get_arg_info", "(", "&", "info", ",", "&", "args", ",", "mode", ",", "type", ",", "true", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_VALUE", "and", "LIBCALL_VALUE", ".", "For", "normal", "calls", ",", "VALTYPE", "is", "the", "return", "type", "and", "MODE", "is", "VOIDmode", ".", "For", "libcalls", ",", "VALTYPE", "is", "null", "and", "MODE", "is", "the", "mode", "of", "the", "return", "value", "." ]

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

[]

[ "<s>", "int", "AMDGPUInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "AMDGPUSubtargetToSISubtarget", "(", "RI", ".", "ST", ".", "getGeneration", "(", ")", ")", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "R600", "SI", "1", "1", "1" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "PerformCMOVCombine", "(", "SDNode", "*", "N", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Cmp", "=", "N", "->", "getOperand", "(", "4", ")", ";", "if", "(", "Cmp", ".", "getOpcode", "(", ")", "!=", "ARMISD", "::", "CMPZ", ")", "return", "SDValue", "(", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "LHS", "=", "Cmp", ".", "getOperand", "(", "0", ")", ";", "SDValue", "RHS", "=", "Cmp", ".", "getOperand", "(", "1", ")", ";", "SDValue", "FalseVal", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "TrueVal", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "ARMcc", "=", "N", "->", "getOperand", "(", "2", ")", ";", "ARMCC", "::", "CondCodes", "CC", "=", "(", "ARMCC", "::", "CondCodes", ")", "cast", "<", "ConstantSDNode", ">", "(", "ARMcc", ")", "->", "getZExtValue", "(", ")", ";", "SDValue", "Res", ";", "if", "(", "CC", "==", "ARMCC", "::", "NE", "&&", "FalseVal", "==", "RHS", "&&", "FalseVal", "!=", "LHS", ")", "{", "Res", "=", "DAG", ".", "getNode", "(", "ARMISD", "::", "CMOV", ",", "dl", ",", "VT", ",", "LHS", ",", "TrueVal", ",", "ARMcc", ",", "N", "->", "getOperand", "(", "3", ")", ",", "Cmp", ")", ";", "}", "else", "if", "(", "CC", "==", "ARMCC", "::", "EQ", "&&", "TrueVal", "==", "RHS", ")", "{", "SDValue", "ARMcc", ";", "SDValue", "NewCmp", "=", "getARMCmp", "(", "LHS", ",", "RHS", ",", "ISD", "::", "SETNE", ",", "ARMcc", ",", "DAG", ",", "dl", ")", ";", "Res", "=", "DAG", ".", "getNode", "(", "ARMISD", "::", "CMOV", ",", "dl", ",", "VT", ",", "LHS", ",", "FalseVal", ",", "ARMcc", ",", "N", "->", "getOperand", "(", "3", ")", ",", "NewCmp", ")", ";", "}", "if", "(", "Res", ".", "getNode", "(", ")", ")", "{", "APInt", "KnownZero", ",", "KnownOne", ";", "DAG", ".", "computeKnownBits", "(", "SDValue", "(", "N", ",", "0", ")", ",", "KnownZero", ",", "KnownOne", ")", ";", "if", "(", "KnownZero", "==", "0xfffffffe", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i1", ")", ")", ";", "else", "if", "(", "KnownZero", "==", "0xffffff00", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i8", ")", ")", ";", "else", "if", "(", "KnownZero", "==", "0xffff0000", ")", "Res", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "dl", ",", "MVT", "::", "i32", ",", "Res", ",", "DAG", ".", "getValueType", "(", "MVT", "::", "i16", ")", ")", ";", "}", "return", "Res", ";", "}", "</s>" ]

[ "PerformCMOVCombine", "-", "Target-specific", "DAG", "combining", "for", "ARMISD", ":", ":CMOV", "." ]

[ "ARM", "ARM", "4", "ARMISD::CMPZ", "0", "0", "1", "0", "1", "ARM", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "ARM", "ARMCC::NE", "ARMISD::CMOV", "ARM", "3", "ARMCC::EQ", "ARM", "ARM", "ISD::SETNE", "ARM", "ARMISD::CMOV", "ARM", "3", "0", "0xfffffffe", "ISD::AssertZext", "MVT::i32", "MVT::i1", "0xffffff00", "ISD::AssertZext", "MVT::i32", "MVT::i8", "0xffff0000", "ISD::AssertZext", "MVT::i32", "MVT::i16" ]

[]

[ "<s>", "void", "HvxSelector", "::", "materialize", "(", "const", "ResultStack", "&", "Results", ")", "{", "DEBUG_WITH_TYPE", "(", "\"isel\"", ",", "{", "dbgs", "(", ")", "<<", "\"Materializing\\n\"", ";", "Results", ".", "print", "(", "dbgs", "(", ")", ",", "DAG", ")", ";", "}", ")", ";", "if", "(", "Results", ".", "empty", "(", ")", ")", "return", ";", "const", "SDLoc", "&", "dl", "(", "Results", ".", "InpNode", ")", ";", "std", "::", "vector", "<", "SDValue", ">", "Output", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Results", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "NodeTemplate", "&", "Node", "=", "Results", "[", "I", "]", ";", "std", "::", "vector", "<", "SDValue", ">", "Ops", ";", "for", "(", "const", "OpRef", "&", "R", ":", "Node", ".", "Ops", ")", "{", "assert", "(", "R", ".", "isValid", "(", ")", ")", ";", "if", "(", "R", ".", "isValue", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "R", ".", "OpV", ")", ";", "continue", ";", "}", "if", "(", "R", ".", "OpN", "&", "OpRef", "::", "Undef", ")", "{", "MVT", "::", "SimpleValueType", "SVT", "=", "MVT", "::", "SimpleValueType", "(", "R", ".", "OpN", "&", "OpRef", "::", "Index", ")", ";", "Ops", ".", "push_back", "(", "ISel", ".", "selectUndef", "(", "dl", ",", "MVT", "(", "SVT", ")", ")", ")", ";", "continue", ";", "}", "unsigned", "Part", "=", "R", ".", "OpN", "&", "OpRef", "::", "Whole", ";", "int", "Idx", "=", "SignExtend32", "(", "R", ".", "OpN", "&", "OpRef", "::", "Index", ",", "OpRef", "::", "IndexBits", ")", ";", "if", "(", "Idx", "<", "0", ")", "Idx", "+=", "I", ";", "assert", "(", "Idx", ">=", "0", "&&", "unsigned", "(", "Idx", ")", "<", "Output", ".", "size", "(", ")", ")", ";", "SDValue", "Op", "=", "Output", "[", "Idx", "]", ";", "MVT", "OpTy", "=", "Op", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "if", "(", "Part", "!=", "OpRef", "::", "Whole", ")", "{", "assert", "(", "Part", "==", "OpRef", "::", "LoHalf", "||", "Part", "==", "OpRef", "::", "HiHalf", ")", ";", "MVT", "HalfTy", "=", "MVT", "::", "getVectorVT", "(", "OpTy", ".", "getVectorElementType", "(", ")", ",", "OpTy", ".", "getVectorNumElements", "(", ")", "/", "2", ")", ";", "unsigned", "Sub", "=", "(", "Part", "==", "OpRef", "::", "LoHalf", ")", "?", "Hexagon", "::", "vsub_lo", ":", "Hexagon", "::", "vsub_hi", ";", "Op", "=", "DAG", ".", "getTargetExtractSubreg", "(", "Sub", ",", "dl", ",", "HalfTy", ",", "Op", ")", ";", "}", "Ops", ".", "push_back", "(", "Op", ")", ";", "}", "assert", "(", "Node", ".", "Ty", "!=", "MVT", "::", "Other", ")", ";", "SDNode", "*", "ResN", "=", "(", "Node", ".", "Opc", "==", "TargetOpcode", "::", "COPY", ")", "?", "Ops", ".", "front", "(", ")", ".", "getNode", "(", ")", ":", "DAG", ".", "getMachineNode", "(", "Node", ".", "Opc", ",", "dl", ",", "Node", ".", "Ty", ",", "Ops", ")", ";", "Output", ".", "push_back", "(", "SDValue", "(", "ResN", ",", "0", ")", ")", ";", "}", "SDNode", "*", "OutN", "=", "Output", ".", "back", "(", ")", ".", "getNode", "(", ")", ";", "SDNode", "*", "InpN", "=", "Results", ".", "InpNode", ";", "DEBUG_WITH_TYPE", "(", "\"isel\"", ",", "{", "dbgs", "(", ")", "<<", "\"Generated node:\\n\"", ";", "OutN", "->", "dumpr", "(", "&", "DAG", ")", ";", "}", ")", ";", "ISel", ".", "ReplaceNode", "(", "InpN", ",", "OutN", ")", ";", "selectVectorConstants", "(", "OutN", ")", ";", "DAG", ".", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "\"isel\"", "\"Materializing\\n\"", "0", "MVT::SimpleValueType", "MVT::SimpleValueType", "0", "0", "MVT::getVectorVT", "2", "Hexagon::vsub_lo", "Hexagon::vsub_hi", "MVT::Other", "0", "\"isel\"", "\"Generated node:\\n\"" ]

[]

[ "<s>", "void", "AVRAsmPrinter", "::", "emitXXStructor", "(", "const", "DataLayout", "&", "DL", ",", "const", "Constant", "*", "CV", ")", "{", "if", "(", "!", "EmittedStructorSymbolAttrs", ")", "{", "OutStreamer", "->", "emitRawComment", "(", "\" Emitting these undefined symbol references causes us to link the\"", "\" libgcc code that runs our constructors/destructors\"", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" This matches GCC's behavior\"", ")", ";", "MCSymbol", "*", "CtorsSym", "=", "OutContext", ".", "getOrCreateSymbol", "(", "\"__do_global_ctors\"", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "CtorsSym", ",", "MCSA_Global", ")", ";", "MCSymbol", "*", "DtorsSym", "=", "OutContext", ".", "getOrCreateSymbol", "(", "\"__do_global_dtors\"", ")", ";", "OutStreamer", "->", "emitSymbolAttribute", "(", "DtorsSym", ",", "MCSA_Global", ")", ";", "EmittedStructorSymbolAttrs", "=", "true", ";", "}", "AsmPrinter", "::", "emitXXStructor", "(", "DL", ",", "CV", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "change", "how", "global", "constants", "that", "are", "part", "of", "a", "C++", "static/global", "constructor", "list", "are", "emitted", "." ]

[ "AVR", "AVR", "\" Emitting these undefined symbol references causes us to link the\"", "\" libgcc code that runs our constructors/destructors\"", "\" This matches GCC's behavior\"", "\"__do_global_ctors\"", "\"__do_global_dtors\"" ]

[]

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

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

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos Ensure Alignment\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Ensure Alignment\"" ]

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", "&&", "!", "(", "hasFP", "(", "MF", ")", "&&", "hasRVVFrameObject", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "PPCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createPPCEarlyReturnPass", "(", ")", ")", ";", "addPass", "(", "createPPCBranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Asm", ",", "Fixup", ",", "Target", ",", "Value", ",", "IsResolved", ",", "Ctx", ",", "STI", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "unsigned", "FullSizeBytes", ";", "if", "(", "Endian", "==", "support", "::", "big", ")", "{", "FullSizeBytes", "=", "getFixupKindContainerSizeBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "(", "Offset", "+", "FullSizeBytes", ")", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup size!\"", ")", ";", "assert", "(", "NumBytes", "<=", "FullSizeBytes", "&&", "\"Invalid fixup size!\"", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "Endian", "==", "support", "::", "little", "?", "i", ":", "(", "FullSizeBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "support::big", "\"Invalid fixup size!\"", "\"Invalid fixup size!\"", "0", "support::little", "1", "8", "0xff" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "override", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "8" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "int64_t", "TailCallReturnAddrDelta", "=", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "TailCallReturnAddrDelta", "<", "0", ")", "{", "MFI", "->", "CreateFixedObject", "(", "-", "TailCallReturnAddrDelta", ",", "TailCallReturnAddrDelta", "-", "SlotSize", ",", "true", ")", ";", "}", "if", "(", "TRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "TRI", "->", "getBaseRegister", "(", ")", ")", ";", "if", "(", "MF", ".", "getMMI", "(", ")", ".", "hasEHFunclets", "(", ")", ")", "{", "int", "FI", "=", "MFI", "->", "CreateSpillStackObject", "(", "SlotSize", ",", "SlotSize", ")", ";", "X86FI", "->", "setHasSEHFramePtrSave", "(", "true", ")", ";", "X86FI", "->", "setSEHFramePtrSaveIndex", "(", "FI", ")", ";", "}", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "KILLGT", ")", "{", "return", "false", ";", "}", "else", "if", "(", "isVector", "(", "*", "MI", ")", ")", "{", "return", "false", ";", "}", "else", "{", "return", "AMDGPUInstrInfo", "::", "isPredicable", "(", "MI", ")", ";", "}", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "XCoreTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "XCore", "::", "GRRegsRegClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "XCore", "XCore", "1", "0", "0U", "XCore::GRRegsRegClass" ]

[]

[ "<s>", "bool", "XNCMTargetLowering", "::", "isZExtFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "return", "0", "&&", "VT1", "==", "MVT", "::", "i8", "&&", "VT2", "==", "MVT", "::", "i16", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "XNCM", "XNCM", "0", "MVT::i8", "MVT::i16" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "lowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "lowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "lowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "lowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "lowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "lowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "lowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "lowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "lowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "lowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "lowerADD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "lowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "ISD::BRCOND", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::BlockAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::VASTART", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::EH_RETURN", "ISD::ADD", "ISD::ATOMIC_FENCE" ]

[]

[ "<s>", "bool", "NVPTXDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ";", "return", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "int", "BSideAssigner", "::", "select", "(", "int", "side", ",", "const", "res_set_t", "&", "set", ")", "{", "assert", "(", "set", ".", "size", "(", ")", ")", ";", "if", "(", "set", ".", "size", "(", ")", "==", "1", ")", "return", "-", "1", ";", "for", "(", "res_set_t", "::", "const_iterator", "I", "=", "set", ".", "begin", "(", ")", ",", "E", "=", "set", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "(", "*", "I", "&", "0x1", ")", "==", "side", ")", "return", "*", "I", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "TMS320C64X", "1", "1", "0x1", "1" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "PPCRegisterInfo", "::", "getPointerRegClass", "(", ")", "const", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "&", "PPC", "::", "G8RCRegClass", ";", "else", "return", "&", "PPC", "::", "GPRCRegClass", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "fold_mergehl_helper", "(", "gimple_stmt_iterator", "*", "gsi", ",", "gimple", "*", "stmt", ",", "int", "use_high", ")", "{", "tree", "arg0", "=", "gimple_call_arg", "(", "stmt", ",", "0", ")", ";", "tree", "arg1", "=", "gimple_call_arg", "(", "stmt", ",", "1", ")", ";", "tree", "lhs", "=", "gimple_call_lhs", "(", "stmt", ")", ";", "tree", "lhs_type", "=", "TREE_TYPE", "(", "lhs", ")", ";", "int", "n_elts", "=", "TYPE_VECTOR_SUBPARTS", "(", "lhs_type", ")", ";", "int", "midpoint", "=", "n_elts", "/", "2", ";", "int", "offset", "=", "0", ";", "if", "(", "use_high", "==", "1", ")", "offset", "=", "midpoint", ";", "tree", "permute_type", ";", "permute_type", "=", "map_to_integral_tree_type", "(", "lhs_type", ")", ";", "tree_vector_builder", "elts", "(", "permute_type", ",", "VECTOR_CST_NELTS", "(", "arg0", ")", ",", "1", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "midpoint", ";", "i", "++", ")", "{", "elts", ".", "safe_push", "(", "build_int_cst", "(", "TREE_TYPE", "(", "permute_type", ")", ",", "offset", "+", "i", ")", ")", ";", "elts", ".", "safe_push", "(", "build_int_cst", "(", "TREE_TYPE", "(", "permute_type", ")", ",", "offset", "+", "n_elts", "+", "i", ")", ")", ";", "}", "tree", "permute", "=", "elts", ".", "build", "(", ")", ";", "gimple", "*", "g", "=", "gimple_build_assign", "(", "lhs", ",", "VEC_PERM_EXPR", ",", "arg0", ",", "arg1", ",", "permute", ")", ";", "gimple_set_location", "(", "g", ",", "gimple_location", "(", "stmt", ")", ")", ";", "gsi_replace", "(", "gsi", ",", "g", ",", "true", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "handle", "the", "vector", "merge", "[", "hl", "]", "built-ins", ".", "The", "implementation", "difference", "between", "h", "and", "l", "versions", "for", "this", "code", "are", "in", "the", "values", "used", "when", "building", "of", "the", "permute", "vector", "for", "high", "word", "versus", "low", "word", "merge", ".", "The", "variance", "is", "keyed", "off", "the", "use_high", "parameter", "." ]

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

[]

[ "<s>", "MCObjectWriter", "*", "BPFAsmBackend", "::", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "{", "return", "createBPFELFObjectWriter", "(", "OS", ",", "0", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

[ "BPF", "BPF", "BPF", "0" ]

[]

[ "<s>", "static", "void", "split_plus", "(", "rtx", "x", ",", "rtx", "*", "base_ptr", ",", "HOST_WIDE_INT", "*", "offset_ptr", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "*", "base_ptr", "=", "XEXP", "(", "x", ",", "0", ")", ";", "*", "offset_ptr", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "else", "{", "*", "base_ptr", "=", "x", ";", "*", "offset_ptr", "=", "0", ";", "}", "}", "</s>" ]

[ "If", "X", "is", "a", "PLUS", "of", "a", "CONST_INT", ",", "return", "the", "two", "terms", "in", "*", "BASE_PTR", "and", "*", "OFFSET_PTR", ".", "Return", "X", "in", "*", "BASE_PTR", "and", "0", "in", "*", "OFFSET_PTR", "otherwise", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARMFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "isARM", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", ";", "DebugLoc", "dl", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "unsigned", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This eliminateCallFramePseudoInstr does not support Thumb1!\"", ")", ";", "int", "PIdx", "=", "I", "->", "findFirstPredOperandIdx", "(", ")", ";", "ARMCC", "::", "CondCodes", "Pred", "=", "(", "PIdx", "==", "-", "1", ")", "?", "ARMCC", "::", "AL", ":", "(", "ARMCC", "::", "CondCodes", ")", "I", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "PredReg", "=", "TII", ".", "getFramePred", "(", "*", "I", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "if", "(", "IsDestroy", "&&", "CalleePopAmount", "!=", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "unsigned", "Amount", "=", "TII", ".", "getFrameSize", "(", "*", "I", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "else", "{", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "}", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "CalleePopAmount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "return", "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", ")", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "1", "0", "\"This eliminateCallFramePseudoInstr does not support Thumb1!\"", "ARMCC::CondCodes", "1", "ARMCC::AL", "ARMCC::CondCodes", "0", "0", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "ARM", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP", "ARM", "0", "ARM" ]

[]

[ "<s>", "int", "addr32_operand", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "rtx", "sym", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "LABEL_REF", ")", "return", "TARGET_ADDR32", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "sym", "=", "op", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "CONST_INT_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", "&&", "!", "flag_pic", ")", "sym", "=", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ";", "else", "return", "0", ";", "return", "(", "!", "addr24_operand", "(", "sym", ",", "mode", ")", "&&", "!", "small_data_operand", "(", "sym", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "symbol", "that", "needs", "32", "bit", "addressing", "." ]

[ "m32r", "0", "0", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getIntrinsicInstrCost", "(", "const", "IntrinsicCostAttributes", "&", "ICA", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "ICA", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "AMDGPUDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "if", "(", "!", "Subtarget", "->", "d16PreservesUnusedBits", "(", ")", ")", "return", ";", "SelectionDAG", "::", "allnodes_iterator", "Position", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "&", "*", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", ")", "continue", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BUILD_VECTOR", ":", "MadeChange", "|=", "matchLoadD16FromBuildVector", "(", "N", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "if", "(", "MadeChange", ")", "{", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"After PreProcess:\\n\"", ";", "CurDAG", "->", "dump", "(", ")", ";", ")", ";", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "AMDGPU", "AMDGPU", "ISD::BUILD_VECTOR", "\"After PreProcess:\\n\"" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "for", "(", "std", "::", "map", "<", "const", "char", "*", ",", "const", "llvm", "::", "Mips16HardFloatInfo", "::", "FuncSignature", "*", ">", "::", "const_iterator", "it", "=", "MipsFI", "->", "StubsNeeded", ".", "begin", "(", ")", ";", "it", "!=", "MipsFI", "->", "StubsNeeded", ".", "end", "(", ")", ";", "++", "it", ")", "{", "const", "char", "*", "Symbol", "=", "it", "->", "first", ";", "const", "llvm", "::", "Mips16HardFloatInfo", "::", "FuncSignature", "*", "Signature", "=", "it", "->", "second", ";", "if", "(", "StubsNeeded", ".", "find", "(", "Symbol", ")", "==", "StubsNeeded", ".", "end", "(", ")", ")", "StubsNeeded", "[", "Symbol", "]", "=", "Signature", ";", "}", "MCP", "=", "MF", ".", "getConstantPool", "(", ")", ";", "if", "(", "Subtarget", "->", "isTargetNaCl", "(", ")", ")", "NaClAlignIndirectJumpTargets", "(", "MF", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "EmitXRayTable", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature", "Mips", "Mips", "Mips16HardFloatInfo::FuncSignature" ]

[]

[ "<s>", "static", "reg_class_t", "ix86_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "regclass", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "if", "(", "regclass", "==", "NO_REGS", ")", "return", "NO_REGS", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "regclass", ";", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "(", "MAYBE_MMX_CLASS_P", "(", "regclass", ")", "||", "MAYBE_SSE_CLASS_P", "(", "regclass", ")", "||", "MAYBE_MASK_CLASS_P", "(", "regclass", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "TARGET_SSE_MATH", "&&", "!", "TARGET_MIX_SSE_I387", "&&", "SSE_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "SSE_CLASS_P", "(", "regclass", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "x", ")", "!=", "VOIDmode", ")", "{", "if", "(", "reg_class_subset_p", "(", "regclass", ",", "GENERAL_REGS", ")", ")", "return", "regclass", ";", "if", "(", "TARGET_80387", "&&", "standard_80387_constant_p", "(", "x", ")", ">", "0", ")", "{", "if", "(", "regclass", "==", "FLOAT_SSE_REGS", ")", "return", "FLOAT_REGS", ";", "if", "(", "regclass", "==", "FP_TOP_SSE_REGS", ")", "return", "FP_TOP_REG", ";", "if", "(", "regclass", "==", "FP_SECOND_SSE_REGS", ")", "return", "FP_SECOND_REG", ";", "if", "(", "regclass", "==", "FLOAT_INT_REGS", "||", "regclass", "==", "FLOAT_REGS", ")", "return", "regclass", ";", "}", "return", "NO_REGS", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "reg_class_subset_p", "(", "regclass", ",", "GENERAL_REGS", ")", "?", "regclass", ":", "NO_REGS", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", "&&", "!", "CONSTANT_P", "(", "x", ")", ")", "{", "if", "(", "reg_class_subset_p", "(", "regclass", ",", "Q_REGS", ")", ")", "return", "regclass", ";", "if", "(", "reg_class_subset_p", "(", "Q_REGS", ",", "regclass", ")", ")", "return", "Q_REGS", ";", "return", "NO_REGS", ";", "}", "return", "regclass", ";", "}", "</s>" ]

[ "Put", "float", "CONST_DOUBLE", "in", "the", "constant", "pool", "instead", "of", "fp", "regs", ".", "QImode", "must", "go", "into", "class", "Q_REGS", ".", "Narrow", "ALL_REGS", "to", "GENERAL_REGS", ".", "This", "supports", "allowing", "movsf", "and", "movdf", "to", "do", "mem-to-mem", "moves", "through", "integer", "regs", "." ]

[ "i386", "0" ]

[]

[ "<s>", "static", "rtx", "bpf_function_value", "(", "const_tree", "ret_type", ",", "const_tree", "fntype_or_decl", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", ";", "int", "unsignedp", ";", "mode", "=", "TYPE_MODE", "(", "ret_type", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "ret_type", ")", ")", "mode", "=", "promote_function_mode", "(", "ret_type", ",", "mode", ",", "&", "unsignedp", ",", "fntype_or_decl", ",", "1", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "BPF_R0", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "representing", "the", "place", "where", "a", "function", "returns", "or", "receives", "a", "value", "of", "data", "type", "RET_TYPE", ",", "a", "tree", "node", "representing", "a", "data", "type", "." ]

[ "bpf", "1" ]

[]

[ "<s>", "bool", "Cpu0TargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "Cpu0", "Cpu0", "0", "1" ]

[]

[ "<s>", "bool", "HSAILAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "EmitEndOfAsmFile", "(", "M", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "bool", "AMDGPUPerfHint", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "const", "Module", "&", "M", "=", "*", "F", ".", "getParent", "(", ")", ";", "DL", "=", "&", "M", ".", "getDataLayout", "(", ")", ";", "if", "(", "F", ".", "hasFnAttribute", "(", "\"amdgpu-wave-limiter\"", ")", "&&", "F", ".", "hasFnAttribute", "(", "\"amdgpu-memory-bound\"", ")", ")", "return", "false", ";", "const", "AMDGPUPerfHintAnalysis", "::", "FuncInfo", "*", "Info", "=", "visit", "(", "F", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" MemInst cost: \"", "<<", "Info", "->", "MemInstCost", "<<", "'\\n'", "<<", "\" IAMInst cost: \"", "<<", "Info", "->", "IAMInstCost", "<<", "'\\n'", "<<", "\" LSMInst cost: \"", "<<", "Info", "->", "LSMInstCost", "<<", "'\\n'", "<<", "\" TotalInst cost: \"", "<<", "Info", "->", "InstCost", "<<", "'\\n'", ")", ";", "bool", "Changed", "=", "false", ";", "if", "(", "isMemBound", "(", "*", "Info", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" is memory bound\\n\"", ")", ";", "NumMemBound", "++", ";", "F", ".", "addFnAttr", "(", "\"amdgpu-memory-bound\"", ",", "\"true\"", ")", ";", "Changed", "=", "true", ";", "}", "if", "(", "AMDGPU", "::", "isEntryFunctionCC", "(", "F", ".", "getCallingConv", "(", ")", ")", "&&", "needLimitWave", "(", "*", "Info", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "F", ".", "getName", "(", ")", "<<", "\" needs limit wave\\n\"", ")", ";", "NumLimitWave", "++", ";", "F", ".", "addFnAttr", "(", "\"amdgpu-wave-limiter\"", ",", "\"true\"", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"amdgpu-wave-limiter\"", "\"amdgpu-memory-bound\"", "AMDGPU", "\" MemInst cost: \"", "\" IAMInst cost: \"", "\" LSMInst cost: \"", "\" TotalInst cost: \"", "\" is memory bound\\n\"", "\"amdgpu-memory-bound\"", "\"true\"", "AMDGPU::isEntryFunctionCC", "\" needs limit wave\\n\"", "\"amdgpu-wave-limiter\"", "\"true\"" ]

[]

[ "<s>", "char", "*", "msp430_dirname", "(", "char", "*", "path", ")", "{", "int", "last_elem", "=", "strlen", "(", "path", ")", "-", "1", ";", "int", "i", "=", "last_elem", "-", "(", "IS_DIR_SEPARATOR", "(", "path", "[", "last_elem", "]", ")", "?", "1", ":", "0", ")", ";", "for", "(", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "IS_DIR_SEPARATOR", "(", "path", "[", "i", "]", ")", ")", "{", "path", "[", "i", "]", "=", "'\\0'", ";", "return", "path", ";", "}", "}", "return", "path", ";", "}", "</s>" ]

[ "This", "function", "returns", "the", "enclosing", "directory", "of", "PATH", ".", "It", "is", "inconsequential", "whether", "PATH", "ends", "in", "a", "dirsep", "or", "not", ".", "It", "modifies", "the", "string", "pointed", "to", "by", "PATH", "." ]

[ "msp430", "1", "1", "0", "0" ]

[]

[ "<s>", "static", "inline", "void", "w32_error", "(", "const", "char", "*", "function", ",", "const", "char", "*", "file", ",", "int", "line", ",", "const", "char", "*", "my_msg", ")", "{", "LPSTR", "w32_msgbuf", ";", "FormatMessageA", "(", "FORMAT_MESSAGE_ALLOCATE_BUFFER", "|", "FORMAT_MESSAGE_FROM_SYSTEM", "|", "FORMAT_MESSAGE_IGNORE_INSERTS", "|", "FORMAT_MESSAGE_MAX_WIDTH_MASK", ",", "NULL", ",", "GetLastError", "(", ")", ",", "MAKELANGID", "(", "LANG_NEUTRAL", ",", "SUBLANG_DEFAULT", ")", ",", "(", "LPSTR", ")", "&", "w32_msgbuf", ",", "0", ",", "NULL", ")", ";", "fprintf", "(", "stderr", ",", "\"internal error in %s, at %s:%d: %s: %s\\n\"", ",", "function", ",", "trim_filename", "(", "file", ")", ",", "line", ",", "my_msg", ",", "w32_msgbuf", ")", ";", "LocalFree", "(", "(", "HLOCAL", ")", "w32_msgbuf", ")", ";", "}", "</s>" ]

[ "Print", "out", "the", "GetLastError", "(", ")", "translation", "." ]

[ "i386", "0", "\"internal error in %s, at %s:%d: %s: %s\\n\"" ]

[]

[ "<s>", "static", "bool", "rs6000_debug_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "reg_ok_strict", ")", "{", "bool", "ret", "=", "rs6000_legitimate_address_p", "(", "mode", ",", "x", ",", "reg_ok_strict", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_legitimate_address_p: return = %s, mode = %s, \"", "\"strict = %d, reload = %s, code = %s\\n\"", ",", "ret", "?", "\"true\"", ":", "\"false\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "reg_ok_strict", ",", "(", "reload_completed", "?", "\"after\"", ":", "\"before\"", ")", ",", "GET_RTX_NAME", "(", "GET_CODE", "(", "x", ")", ")", ")", ";", "debug_rtx", "(", "x", ")", ";", "return", "ret", ";", "}", "</s>" ]

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

[ "rs6000", "\"\\nrs6000_legitimate_address_p: return = %s, mode = %s, \"", "\"strict = %d, reload = %s, code = %s\\n\"", "\"true\"", "\"false\"", "\"after\"", "\"before\"" ]

[]