Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "PPCTargetMachine", "&", "TM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "getDataLayoutString", "(", "TargetTriple", ")", ")", ",", "IsPPC64", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", "||", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", ")", ",", "OptLevel", "(", "OptLevel", ")", ",", "TargetABI", "(", "PPC_ABI_UNKNOWN", ")", ",", "FrameLowering", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ")", ",", "TSInfo", "(", "&", "DL", ")", "{", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "RISCVInstPrinter", "::", "applyTargetSpecificCLOption", "(", "StringRef", "Opt", ")", "{", "if", "(", "Opt", "==", "\"no-aliases\"", ")", "{", "NoAliases", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Opt", "==", "\"numeric\"", ")", "{", "ArchRegNames", "=", "true", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Customize", "the", "printer", "according", "to", "a", "command", "line", "option", "." ]

[ "RI5CY", "RISCV", "\"no-aliases\"", "\"numeric\"" ]

[]

[ "<s>", "VE", "::", "Fixups", "getFixupKind", "(", ")", "const", "{", "return", "getFixupKind", "(", "Kind", ")", ";", "}", "</s>" ]

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

[ "VE", "VE::Fixups" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Bitcode Writer\"", ";", "}", "</s>" ]

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

[ "DirectX", "\"Bitcode Writer\"" ]

[]

[ "<s>", "static", "bool", "m68hc11_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "4", ")", ";", "}", "else", "return", "GET_MODE_SIZE", "(", "TYPE_MODE", "(", "type", ")", ")", ">", "4", ";", "}", "</s>" ]

[ "Return", "true", "if", "type", "TYPE", "should", "be", "returned", "in", "memory", ".", "Blocks", "and", "data", "types", "largers", "than", "4", "bytes", "can", "not", "be", "returned", "in", "the", "register", "(", "D", "+", "X", "=", "4", ")", "." ]

[ "m68hc11", "1", "4", "4" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "reverse_iterator", "I", "=", "MBB", ".", "rbegin", "(", ")", ",", "REnd", "=", "MBB", ".", "rend", "(", ")", ";", "unsigned", "removed", "=", "0", ";", "while", "(", "I", "!=", "REnd", "&&", "removed", "<", "2", ")", "{", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "{", "++", "I", ";", "continue", ";", "}", "if", "(", "!", "getAnalyzableBrOpc", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "rbegin", "(", ")", ";", "++", "removed", ";", "}", "return", "removed", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"code size not handled\"", "0", "2" ]

[]

[ "<s>", "void", "TPCAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "{", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "void", "*", "Ptr", "=", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "]", ";", "memcpy", "(", "Ptr", ",", "&", "Value", ",", "sizeof", "(", "uint32_t", ")", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_4", ")", "{", "int", "RelOffset", "=", "Value", "&", "0xffffffff", ";", "unsigned", "InstrSize", "=", "TPCII", "::", "InstructionSize", ";", "LLVM_DEBUG", "(", "fprintf", "(", "stderr", ",", "\"applyFixup offset=%d reloc=%d comp=%d\\n\"", ",", "Offset", ",", "RelOffset", ",", "(", "Data", "[", "Offset", "]", "&", "3", ")", ")", ";", ")", ";", "assert", "(", "InstrSize", "%", "64", "==", "0", "&&", "\"Instruction is not aligned to 64 bits anymore, fix relocations\"", ")", ";", "APInt", "Instruction", "(", "InstrSize", ",", "ArrayRef", "<", "uint64_t", ">", "(", "(", "uint64_t", "*", ")", "(", "&", "Data", "[", "Offset", "]", ")", ",", "InstrSize", "/", "64", ")", ")", ";", "APInt", "ImmSlot", "(", "TPCII", "::", "ImmSize", ",", "RelOffset", ")", ";", "Instruction", "|=", "ImmSlot", ".", "zext", "(", "InstrSize", ")", ".", "shl", "(", "TPCII", "::", "ImmStart", ")", ";", "const", "char", "*", "RawInstrucion", "=", "(", "const", "char", "*", ")", "Instruction", ".", "getRawData", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "InstrSize", "/", "8", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "=", "RawInstrucion", "[", "i", "]", ";", "}", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "MCFixupKind", "(", "TPC", "::", "FK_LOOP", ")", ")", "{", "assert", "(", "Value", "!=", "0", "&&", "\"Too short LOOP\"", ")", ";", "if", "(", "(", "Value", "&", "0xffff", ")", "!=", "Value", ")", "{", "report_fatal_error", "(", "\"Too many instructions in the LOOP - END_PC offset does not fit in 16 bits\"", ")", ";", "}", "unsigned", "InstrSize", "=", "TPCII", "::", "InstructionSize", ";", "int", "RelOffset", "=", "(", "Value", "&", "0xffff", ")", "-", "TPCII", "::", "InstructionSize", "/", "8", ";", "LLVM_DEBUG", "(", "fprintf", "(", "stderr", ",", "\"applyFixup LOOP offset=%d reloc=%d comp=%d\\n\"", ",", "Offset", ",", "RelOffset", ",", "(", "Data", "[", "Offset", "]", "&", "3", ")", ")", ";", ")", ";", "APInt", "Instruction", "(", "TPCII", "::", "InstructionSize", ",", "ArrayRef", "<", "uint64_t", ">", "(", "(", "uint64_t", "*", ")", "(", "&", "Data", "[", "Offset", "]", ")", ",", "TPCII", "::", "InstructionSize", "/", "64", ")", ")", ";", "APInt", "ImmSlot", "(", "TPCII", "::", "ImmSize", ",", "RelOffset", ")", ";", "Instruction", "|=", "ImmSlot", ".", "zext", "(", "TPCII", "::", "InstructionSize", ")", ".", "shl", "(", "TPCII", "::", "LoopOffsetStart", ")", ";", "const", "char", "*", "RawInstrucion", "=", "(", "const", "char", "*", ")", "Instruction", ".", "getRawData", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "InstrSize", "/", "8", ";", "++", "i", ")", "{", "Data", "[", "Offset", "+", "i", "]", "=", "RawInstrucion", "[", "i", "]", ";", "}", "}", "}", "</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", "." ]

[ "TPC", "TPC", "0xffffffff", "TPC", "\"applyFixup offset=%d reloc=%d comp=%d\\n\"", "3", "64", "0", "\"Instruction is not aligned to 64 bits anymore, fix relocations\"", "64", "TPC", "TPC", "0", "8", "TPC::FK_LOOP", "0", "\"Too short LOOP\"", "0xffff", "\"Too many instructions in the LOOP - END_PC offset does not fit in 16 bits\"", "TPC", "0xffff", "TPC", "8", "\"applyFixup LOOP offset=%d reloc=%d comp=%d\\n\"", "3", "TPC", "TPC", "64", "TPC", "TPC", "TPC", "0", "8" ]

[]

[ "<s>", "void", "F2003fFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "F2003fInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "F2003fInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "F2003f", "::", "NTAri", ")", ",", "F2003f", "::", "F5", ")", ".", "addReg", "(", "F2003f", "::", "F5", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "}", "</s>" ]

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

[ "F2003f", "F2003f", "\"Shrink-wrapping not yet supported\"", "F2003f", "F2003f", "F2003f::NTAri", "F2003f::F5", "F2003f::F5" ]

[]

[ "<s>", "static", "bool", "aarch64_cheap_mult_shift_p", "(", "rtx", "x", ")", "{", "rtx", "op0", ",", "op1", ";", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "!", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_CHEAP_SHIFT_EXTEND", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "SIGN_EXTEND", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "ASHIFT", "&&", "CONST_INT_P", "(", "op1", ")", "&&", "UINTVAL", "(", "op1", ")", "<=", "4", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MULT", "||", "!", "CONST_INT_P", "(", "op1", ")", ")", "return", "false", ";", "HOST_WIDE_INT", "l2", "=", "exact_log2", "(", "INTVAL", "(", "op1", ")", ")", ";", "if", "(", "l2", ">", "0", "&&", "l2", "<=", "4", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "X", "is", "a", "cheap", "shift", "without", "a", "sign", "extend", "." ]

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

[]

[ "<s>", "void", "OR1KTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "0", ",", "0", ")", ";", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "char", "ConstraintLetter", "=", "Constraint", "[", "0", "]", ";", "switch", "(", "ConstraintLetter", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'J'", ":", "case", "'O'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "0", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'K'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isUInt", "<", "16", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'L'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "31", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getZExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'M'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "(", "isInt", "<", "32", ">", "(", "Val", ")", ")", "&&", "(", "(", "Val", "&", "0xffff", ")", "==", "0", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "case", "'N'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "int64_t", "Val", "=", "C", "->", "getSExtValue", "(", ")", ";", "if", "(", "(", "Val", ">=", "-", "33554432", ")", "&&", "(", "Val", "<=", "33554431", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "Val", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "}", "return", ";", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "OR1K", "OR1K", "0", "0", "1", "0", "16", "0", "0", "16", "31", "32", "0xffff", "0", "33554432", "33554431" ]

[]

[ "<s>", "static", "void", "ia64_vms_init_libfuncs", "(", "void", ")", "{", "set_optab_libfunc", "(", "sdiv_optab", ",", "SImode", ",", "\"OTS$DIV_I\"", ")", ";", "set_optab_libfunc", "(", "sdiv_optab", ",", "DImode", ",", "\"OTS$DIV_L\"", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "SImode", ",", "\"OTS$DIV_UI\"", ")", ";", "set_optab_libfunc", "(", "udiv_optab", ",", "DImode", ",", "\"OTS$DIV_UL\"", ")", ";", "set_optab_libfunc", "(", "smod_optab", ",", "SImode", ",", "\"OTS$REM_I\"", ")", ";", "set_optab_libfunc", "(", "smod_optab", ",", "DImode", ",", "\"OTS$REM_L\"", ")", ";", "set_optab_libfunc", "(", "umod_optab", ",", "SImode", ",", "\"OTS$REM_UI\"", ")", ";", "set_optab_libfunc", "(", "umod_optab", ",", "DImode", ",", "\"OTS$REM_UL\"", ")", ";", "abort_libfunc", "=", "init_one_libfunc", "(", "\"decc$abort\"", ")", ";", "memcmp_libfunc", "=", "init_one_libfunc", "(", "\"decc$memcmp\"", ")", ";", "MEM_LIBFUNCS_INIT", ";", "}", "</s>" ]

[ "Rename", "the", "division", "and", "modulus", "functions", "in", "VMS", "." ]

[ "ia64", "\"OTS$DIV_I\"", "\"OTS$DIV_L\"", "\"OTS$DIV_UI\"", "\"OTS$DIV_UL\"", "\"OTS$REM_I\"", "\"OTS$REM_L\"", "\"OTS$REM_UI\"", "\"OTS$REM_UL\"", "\"decc$abort\"", "\"decc$memcmp\"" ]

[]

[ "<s>", "HOST_WIDE_INT", "arm_compute_initial_elimination_offset", "(", "unsigned", "int", "from", ",", "unsigned", "int", "to", ")", "{", "arm_stack_offsets", "*", "offsets", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "switch", "(", "from", ")", "{", "case", "ARG_POINTER_REGNUM", ":", "switch", "(", "to", ")", "{", "case", "THUMB_HARD_FRAME_POINTER_REGNUM", ":", "return", "0", ";", "case", "FRAME_POINTER_REGNUM", ":", "return", "offsets", "->", "soft_frame", "-", "offsets", "->", "saved_args", ";", "case", "ARM_HARD_FRAME_POINTER_REGNUM", ":", "return", "offsets", "->", "frame", "-", "offsets", "->", "saved_args", "-", "4", ";", "case", "STACK_POINTER_REGNUM", ":", "return", "offsets", "->", "outgoing_args", "-", "(", "offsets", "->", "saved_args", "+", "4", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "case", "FRAME_POINTER_REGNUM", ":", "switch", "(", "to", ")", "{", "case", "THUMB_HARD_FRAME_POINTER_REGNUM", ":", "return", "0", ";", "case", "ARM_HARD_FRAME_POINTER_REGNUM", ":", "return", "offsets", "->", "frame", "-", "offsets", "->", "soft_frame", ";", "case", "STACK_POINTER_REGNUM", ":", "return", "offsets", "->", "outgoing_args", "-", "offsets", "->", "soft_frame", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Compute", "the", "distance", "from", "register", "FROM", "to", "register", "TO", ".", "These", "can", "be", "the", "arg", "pointer", "(", "26", ")", ",", "the", "soft", "frame", "pointer", "(", "25", ")", ",", "the", "stack", "pointer", "(", "13", ")", "or", "the", "hard", "frame", "pointer", "(", "11", ")", ".", "Typical", "stack", "layout", "looks", "like", "this", ":", "old", "stack", "pointer", "-", ">", "|", "|", "--", "--", "|", "|", "\\", "|", "|", "saved", "arguments", "for", "|", "|", "vararg", "functions", "|", "|", "/", "--", "hard", "FP", "&", "arg", "pointer", "-", ">", "|", "|", "\\", "|", "|", "stack", "|", "|", "frame", "|", "|", "/", "--", "|", "|", "\\", "|", "|", "call", "saved", "|", "|", "registers", "soft", "frame", "pointer", "-", ">", "|", "|", "/", "--", "|", "|", "\\", "|", "|", "local", "|", "|", "variables", "|", "|", "/", "--", "|", "|", "\\", "|", "|", "outgoing", "|", "|", "arguments", "current", "stack", "pointer", "-", ">", "|", "|", "/", "--", "For", "a", "given", "funciton", "some", "or", "all", "of", "these", "stack", "compomnents", "may", "not", "be", "needed", ",", "giving", "rise", "to", "the", "possibility", "of", "eliminating", "some", "of", "the", "registers", ".", "The", "values", "returned", "by", "this", "function", "must", "reflect", "the", "behaviour", "of", "arm_expand_prologue", "(", ")", "and", "arm_compute_save_reg_mask", "(", ")", ".", "The", "sign", "of", "the", "number", "returned", "reflects", "the", "direction", "of", "stack", "growth", ",", "so", "the", "values", "are", "positive", "for", "all", "eliminations", "except", "from", "the", "soft", "frame", "pointer", "to", "the", "hard", "frame", "pointer", "." ]

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

[]

[ "<s>", "MachineBasicBlock", "*", "RISCVTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "if", "(", "const", "RISCVVPseudosTable", "::", "PseudoInfo", "*", "RVV", "=", "RISCVVPseudosTable", "::", "getPseudoInfo", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "int", "VLIndex", "=", "RVV", "->", "getVLIndex", "(", ")", ";", "int", "SEWIndex", "=", "RVV", "->", "getSEWIndex", "(", ")", ";", "assert", "(", "SEWIndex", ">=", "0", "&&", "\"SEWIndex must be >= 0\"", ")", ";", "return", "addVSetVL", "(", "MI", ",", "BB", ",", "VLIndex", ",", "SEWIndex", ",", "RVV", "->", "VLMul", ")", ";", "}", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "RISCV", "::", "ReadCycleWide", ":", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"ReadCycleWrite is only to be used on riscv32\"", ")", ";", "return", "emitReadCycleWidePseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "Select_GPR_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR16_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR32_Using_CC_GPR", ":", "case", "RISCV", "::", "Select_FPR64_Using_CC_GPR", ":", "return", "emitSelectPseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "BuildPairF64Pseudo", ":", "return", "emitBuildPairF64Pseudo", "(", "MI", ",", "BB", ")", ";", "case", "RISCV", "::", "SplitF64Pseudo", ":", "return", "emitSplitF64Pseudo", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVVPseudosTable::PseudoInfo", "RISCVVPseudosTable::getPseudoInfo", "0", "\"SEWIndex must be >= 0\"", "\"Unexpected instr type to insert\"", "RISCV::ReadCycleWide", "\"ReadCycleWrite is only to be used on riscv32\"", "RISCV::Select_GPR_Using_CC_GPR", "RISCV::Select_FPR16_Using_CC_GPR", "RISCV::Select_FPR32_Using_CC_GPR", "RISCV::Select_FPR64_Using_CC_GPR", "RISCV::BuildPairF64Pseudo", "RISCV::SplitF64Pseudo" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "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", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasVALU32BitEncoding", "(", "unsigned", "Opcode", ")", "const", "{", "int", "Op32", "=", "AMDGPU", "::", "getVOPe32", "(", "Opcode", ")", ";", "if", "(", "Op32", "==", "-", "1", ")", "return", "false", ";", "return", "pseudoToMCOpcode", "(", "Op32", ")", "!=", "-", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "64-bit", "VALU", "instruction", "has", "a", "32-bit", "encoding", "." ]

[ "AMDGPU", "SI", "AMDGPU::getVOPe32", "1", "1" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addInstSelector", "(", ")", "{", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "createSILowerI1CopiesPass", "(", ")", ")", ";", "addPass", "(", "createSIFixSGPRCopiesPass", "(", "*", "TM", ")", ")", ";", "addPass", "(", "createSIFoldOperandsPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "doFinalization", "(", "Module", "&", "M", ")", "override", "{", "for", "(", "Function", "&", "F", ":", "M", ".", "functions", "(", ")", ")", "{", "if", "(", "F", ".", "getName", "(", ")", ".", "startswith", "(", "\"__\"", ")", ")", "{", "if", "(", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "AlwaysInline", ")", ")", "F", ".", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "F", ".", "setLinkage", "(", "GlobalValue", "::", "LinkageTypes", "::", "AvailableExternallyLinkage", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "TPC", "\"__\"" ]

[]

[ "<s>", "bool", "runOnModule", "(", "Module", "&", "M", ")", "override", "{", "if", "(", "skipModule", "(", "M", ")", ")", "return", "false", ";", "auto", "Changed", "=", "false", ";", "auto", "NvvmMetadata", "=", "M", ".", "getNamedMetadata", "(", "\"nvvm.annotations\"", ")", ";", "if", "(", "!", "NvvmMetadata", ")", "return", "false", ";", "for", "(", "auto", "MetadataNode", ":", "NvvmMetadata", "->", "operands", "(", ")", ")", "{", "if", "(", "MetadataNode", "->", "getNumOperands", "(", ")", "!=", "3", ")", "continue", ";", "const", "MDOperand", "&", "TypeOperand", "=", "MetadataNode", "->", "getOperand", "(", "1", ")", ";", "auto", "Type", "=", "dyn_cast", "<", "MDString", ">", "(", "TypeOperand", ")", ";", "if", "(", "!", "Type", ")", "continue", ";", "if", "(", "Type", "->", "getString", "(", ")", "!=", "\"kernel\"", ")", "continue", ";", "const", "MDOperand", "&", "FuncOperand", "=", "MetadataNode", "->", "getOperand", "(", "0", ")", ";", "if", "(", "!", "FuncOperand", ")", "continue", ";", "auto", "FuncConstant", "=", "dyn_cast", "<", "ConstantAsMetadata", ">", "(", "FuncOperand", ")", ";", "if", "(", "!", "FuncConstant", ")", "continue", ";", "auto", "Func", "=", "dyn_cast", "<", "Function", ">", "(", "FuncConstant", "->", "getValue", "(", ")", ")", ";", "if", "(", "!", "Func", ")", "continue", ";", "auto", "NewFunc", "=", "this", "->", "ProcessFunction", "(", "M", ",", "Func", ")", ";", "if", "(", "NewFunc", ")", "{", "Changed", "=", "true", ";", "MetadataNode", "->", "replaceOperandWith", "(", "0", ",", "llvm", "::", "ConstantAsMetadata", "::", "get", "(", "NewFunc", ")", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "\"nvvm.annotations\"", "3", "1", "\"kernel\"", "0", "0" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", ")", "return", "nullptr", ";", "int", "CommutedOpcode", "=", "commuteOpcode", "(", "*", "MI", ")", ";", "if", "(", "CommutedOpcode", "==", "-", "1", ")", "return", "nullptr", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "assert", "(", "Src0Idx", "!=", "-", "1", "&&", "\"Should always have src0 operand\"", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "!", "Src0", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "nullptr", ";", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "!", "isOperandLegal", "(", "MI", ",", "Src0Idx", ",", "&", "Src1", ")", "||", "!", "isOperandLegal", "(", "MI", ",", "Src1Idx", ",", "&", "Src0", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "!", "Src1", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "!", "Src1", ".", "isImm", "(", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ")", "{", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "int", "Src0ModsVal", "=", "Src0Mods", "->", "getImm", "(", ")", ";", "if", "(", "!", "Src1Mods", "&&", "Src0ModsVal", "!=", "0", ")", "return", "nullptr", ";", "int", "Src1ModsVal", "=", "Src1Mods", "->", "getImm", "(", ")", ";", "assert", "(", "(", "Src1ModsVal", "==", "0", ")", "&&", "\"Not expecting modifiers with immediates\"", ")", ";", "Src1Mods", "->", "setImm", "(", "Src0ModsVal", ")", ";", "Src0Mods", "->", "setImm", "(", "Src1ModsVal", ")", ";", "}", "unsigned", "Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Should only have immediates\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "Src1", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "CommutedOpcode", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "AMDGPU", "SI", "3", "1", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "\"Should always have src0 operand\"", "AMDGPU::getNamedOperandIdx", "AMDGPU::OpName", "1", "AMDGPU::OpName", "AMDGPU::OpName", "0", "0", "\"Not expecting modifiers with immediates\"", "\"Should only have immediates\"" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", "&&", "!", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "continue", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "0", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "unsigned", "SparcRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "llvm_unreachable", "(", "\"What is the return address register\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"What is the return address register\"", "0" ]

[]

[ "<s>", "static", "int", "nds32_force_addi_stack_int", "(", "int", "full_value", ")", "{", "int", "adjust_value", ";", "rtx", "tmp_reg", ";", "rtx", "sp_adjust_insn", ";", "if", "(", "!", "satisfies_constraint_Is15", "(", "GEN_INT", "(", "full_value", ")", ")", ")", "{", "tmp_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "TA_REGNUM", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "GEN_INT", "(", "full_value", ")", ")", ";", "sp_adjust_insn", "=", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp_reg", ")", ";", "sp_adjust_insn", "=", "emit_insn", "(", "sp_adjust_insn", ")", ";", "if", "(", "full_value", "<", "0", ")", "{", "rtx", "plus_rtx", ";", "rtx", "set_rtx", ";", "plus_rtx", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "full_value", ")", ";", "set_rtx", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_rtx", ")", ";", "add_reg_note", "(", "sp_adjust_insn", ",", "REG_FRAME_RELATED_EXPR", ",", "set_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "sp_adjust_insn", ")", "=", "1", ";", "}", "return", "0", ";", "}", "else", "{", "adjust_value", "=", "(", "full_value", "<", "0", ")", "?", "(", "-", "full_value", ")", ":", "(", "full_value", ")", ";", "return", "adjust_value", ";", "}", "}", "</s>" ]

[ "Function", "that", "may", "creates", "more", "instructions", "for", "large", "value", "on", "adjusting", "stack", "pointer", ".", "In", "nds32", "target", ",", "'addi", "'", "can", "be", "used", "for", "stack", "pointer", "adjustment", "in", "prologue/epilogue", "stage", ".", "However", ",", "sometimes", "there", "are", "too", "many", "local", "variables", "so", "that", "the", "adjustment", "value", "is", "not", "able", "to", "be", "fit", "in", "the", "'addi", "'", "instruction", ".", "One", "solution", "is", "to", "move", "value", "into", "a", "register", "and", "then", "use", "'add", "'", "instruction", ".", "In", "practice", ",", "we", "use", "TA_REGNUM", "(", "$", "r15", ")", "to", "accomplish", "this", "purpose", ".", "Also", ",", "we", "need", "to", "return", "zero", "for", "sp", "adjustment", "so", "that", "proglogue/epilogue", "knows", "there", "is", "no", "need", "to", "create", "'addi", "'", "instruction", "." ]

[ "nds32", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addILPOpts", "(", ")", "{", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isFPExtFree", "(", "EVT", "DestVT", ",", "EVT", "SrcVT", ")", "const", "{", "assert", "(", "DestVT", ".", "isFloatingPoint", "(", ")", "&&", "SrcVT", ".", "isFloatingPoint", "(", ")", "&&", "\"invalid fpext types\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "fpext", "operation", "is", "free", "(", "for", "instance", ",", "because", "single-precision", "floating-point", "numbers", "are", "implicitly", "extended", "to", "double-precision", ")", "." ]

[ "PowerPC", "PPC", "\"invalid fpext types\"" ]

[]

[ "<s>", "void", "MCS51TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ADD", ":", "{", "if", "(", "const", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ")", "{", "SDValue", "Sub", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SUB", ",", "DL", ",", "N", "->", "getValueType", "(", "0", ")", ",", "N", "->", "getOperand", "(", "0", ")", ",", "DAG", ".", "getConstant", "(", "-", "C", "->", "getAPIntValue", "(", ")", ",", "DL", ",", "C", "->", "getValueType", "(", "0", ")", ")", ")", ";", "Results", ".", "push_back", "(", "Sub", ")", ";", "}", "break", ";", "}", "default", ":", "{", "SDValue", "Res", "=", "LowerOperation", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "Res", "->", "getNumValues", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "I", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "MCS51", "MCS51", "ISD::ADD", "1", "ISD::SUB", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "RISCVTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "bool", "UseDefaultPreferences", "=", "true", ";", "if", "(", "ST", "->", "getTuneCPU", "(", ")", ".", "contains", "(", "\"sifive-e76\"", ")", "||", "ST", "->", "getTuneCPU", "(", ")", ".", "contains", "(", "\"sifive-s76\"", ")", "||", "ST", "->", "getTuneCPU", "(", ")", ".", "contains", "(", "\"sifive-u74\"", ")", "||", "ST", "->", "getTuneCPU", "(", ")", ".", "contains", "(", "\"sifive-7\"", ")", ")", "UseDefaultPreferences", "=", "false", ";", "if", "(", "UseDefaultPreferences", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "if", "(", "getBooleanLoopAttribute", "(", "L", ",", "\"llvm.loop.isvectorized\"", ")", ")", "return", ";", "InstructionCost", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "if", "(", "const", "Function", "*", "F", "=", "cast", "<", "CallBase", ">", "(", "I", ")", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ">", "Operands", "(", "I", ".", "operand_values", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ",", "TargetTransformInfo", "::", "TCK_SizeAndLatency", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "RISCV", "RISCV", "\"sifive-e76\"", "\"sifive-s76\"", "\"sifive-u74\"", "\"sifive-7\"", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "\"llvm.loop.isvectorized\"", "0", "\"Cost of loop: \"", "\"\\n\"", "60", "12" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "buildOutlinedFrame", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "OutlinedFunction", "&", "OF", ")", "const", "{", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "{", "MachineInstr", "*", "Call", "=", "&", "*", "--", "MBB", ".", "instr_end", "(", ")", ";", "bool", "isThumb", "=", "Subtarget", ".", "isThumb", "(", ")", ";", "unsigned", "FuncOp", "=", "isThumb", "?", "2", ":", "0", ";", "unsigned", "Opc", "=", "Call", "->", "getOperand", "(", "FuncOp", ")", ".", "isReg", "(", ")", "?", "isThumb", "?", "ARM", "::", "tTAILJMPr", ":", "ARM", "::", "TAILJMPr", ":", "isThumb", "?", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "ARM", "::", "tTAILJMPd", ":", "ARM", "::", "tTAILJMPdND", ":", "ARM", "::", "TAILJMPd", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Call", "->", "getOperand", "(", "FuncOp", ")", ")", ";", "if", "(", "isThumb", "&&", "!", "Call", "->", "getOperand", "(", "FuncOp", ")", ".", "isReg", "(", ")", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "Call", "->", "eraseFromParent", "(", ")", ";", "}", "auto", "IsNonTailCall", "=", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCall", "(", ")", "&&", "!", "MI", ".", "isReturn", "(", ")", ";", "}", ";", "if", "(", "std", "::", "any_of", "(", "MBB", ".", "instr_begin", "(", ")", ",", "MBB", ".", "instr_end", "(", ")", ",", "IsNonTailCall", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "It", "=", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "Et", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerTailCall", "||", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "Et", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "MBB", ".", "isLiveIn", "(", "ARM", "::", "LR", ")", ")", "MBB", ".", "addLiveIn", "(", "ARM", "::", "LR", ")", ";", "saveLROnStack", "(", "MBB", ",", "It", ")", ";", "unsigned", "StackAlignment", "=", "Subtarget", ".", "getStackAlignment", "(", ")", ".", "value", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "ARM", "::", "LR", ",", "true", ")", ";", "int64_t", "StackPosEntry", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "cfiDefCfaOffset", "(", "nullptr", ",", "StackAlignment", ")", ")", ";", "BuildMI", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "StackPosEntry", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "int64_t", "LRPosEntry", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "StackAlignment", ")", ")", ";", "BuildMI", "(", "MBB", ",", "It", ",", "DebugLoc", "(", ")", ",", "get", "(", "ARM", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "LRPosEntry", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "restoreLRFromStack", "(", "MBB", ",", "Et", ")", ";", "}", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerTailCall", "||", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "return", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "get", "(", "Subtarget", ".", "getReturnOpcode", "(", ")", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "custom", "frame", "for", "outlined", "functions", "." ]

[ "ARM", "ARM", "2", "0", "ARM::tTAILJMPr", "ARM::TAILJMPr", "ARM::tTAILJMPd", "ARM::tTAILJMPdND", "ARM::TAILJMPd", "ARMCC::AL", "ARM::LR", "ARM::LR", "ARM::LR", "ARM::CFI_INSTRUCTION", "ARM::CFI_INSTRUCTION", "ARMCC::AL" ]

[]

[ "<s>", "void", "MipsCodeEmitter", "::", "emitInstruction", "(", "const", "MachineInstr", "&", "MI", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"JIT: \"", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "\":\\t\"", "<<", "MI", ")", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "true", ")", ";", "if", "(", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "MipsII", "::", "FormMask", ")", "==", "MipsII", "::", "Pseudo", ")", "return", ";", "emitWordLE", "(", "getBinaryCodeForInstr", "(", "MI", ")", ")", ";", "++", "NumEmitted", ";", "MCE", ".", "processDebugLoc", "(", "MI", ".", "getDebugLoc", "(", ")", ",", "false", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "Mips", "Mips", "\"JIT: \"", "\":\\t\"", "MipsII::FormMask", "MipsII::Pseudo" ]

[]

[ "<s>", "machine_mode", "epiphany_select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "rtx", "y", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_FLOAT", ")", "{", "if", "(", "TARGET_SOFT_CMPSF", "||", "op", "==", "ORDERED", "||", "op", "==", "UNORDERED", ")", "{", "if", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "return", "CC_FP_EQmode", ";", "if", "(", "op", "==", "ORDERED", "||", "op", "==", "UNORDERED", ")", "return", "CC_FP_ORDmode", ";", "if", "(", "op", "==", "UNEQ", "||", "op", "==", "LTGT", ")", "return", "CC_FP_UNEQmode", ";", "return", "CC_FP_GTEmode", ";", "}", "return", "CC_FPmode", ";", "}", "else", "if", "(", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "&&", "GET_CODE", "(", "x", ")", "==", "ZERO_EXTRACT", "&&", "XEXP", "(", "x", ",", "1", ")", "==", "const1_rtx", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "2", ")", ")", ")", "return", "CC_N_NEmode", ";", "else", "if", "(", "(", "op", "==", "GEU", "||", "op", "==", "LTU", ")", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "return", "CC_C_LTUmode", ";", "else", "if", "(", "(", "op", "==", "LEU", "||", "op", "==", "GTU", ")", "&&", "GET_CODE", "(", "x", ")", "==", "MINUS", ")", "return", "CC_C_GTUmode", ";", "else", "return", "CCmode", ";", "}", "</s>" ]

[ "Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", "." ]

[ "epiphany", "1", "2" ]

[]

[ "<s>", "int", "SIInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16Buf", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "{", "switch", "(", "ST", ".", "getGeneration", "(", ")", ")", "{", "default", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX9", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA9", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX10", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA10", ";", "break", ";", "}", "}", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "if", "(", "isAsmOnlyOpcode", "(", "MCOp", ")", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::D16Buf", "SIEncodingFamily::GFX80", "SIInstrFlags::SDWA", "SIEncodingFamily::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "AMDGPU", "SIEncodingFamily::SDWA10", "AMDGPU::getMCOpcode", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "tree", "msp430_attr", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "if", "(", "args", "!=", "NULL", ")", "{", "gcc_assert", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "switch", "(", "TREE_CODE", "(", "value", ")", ")", "{", "case", "STRING_CST", ":", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"reset\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"nmi\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"watchdog\"", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"unrecognized interrupt vector argument of %qE attribute\"", ",", "name", ")", ";", "break", ";", "case", "INTEGER_CST", ":", "if", "(", "wi", "::", "gtu_p", "(", "wi", "::", "to_wide", "(", "value", ")", ",", "63", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"numeric argument of %qE attribute must be in range 0..63\"", ",", "name", ")", ";", "break", ";", "default", ":", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant or number\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "break", ";", "}", "}", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "message", "=", "\"%qE attribute only applies to functions\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "&&", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "message", "=", "\"interrupt handlers must be void\"", ";", "if", "(", "!", "TREE_PUBLIC", "(", "*", "node", ")", ")", "message", "=", "\"interrupt handlers cannot be static\"", ";", "TREE_USED", "(", "*", "node", ")", "=", "1", ";", "DECL_PRESERVE_P", "(", "*", "node", ")", "=", "1", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_REENT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be reentrant\"", ";", "else", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be reentrant\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_CRIT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be critical\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be critical\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_NAKED", ")", ")", "{", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be naked\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be naked\"", ";", "}", "if", "(", "message", ")", "{", "warning", "(", "OPT_Wattributes", ",", "message", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Verify", "MSP430", "specific", "attributes", "." ]

[ "msp430", "\"reset\"", "\"nmi\"", "\"watchdog\"", "\"unrecognized interrupt vector argument of %qE attribute\"", "63", "\"numeric argument of %qE attribute must be in range 0..63\"", "\"argument of %qE attribute is not a string constant or number\"", "\"%qE attribute only applies to functions\"", "\"interrupt handlers must be void\"", "\"interrupt handlers cannot be static\"", "1", "1", "\"naked functions cannot be reentrant\"", "\"critical functions cannot be reentrant\"", "\"naked functions cannot be critical\"", "\"reentrant functions cannot be critical\"", "\"critical functions cannot be naked\"", "\"reentrant functions cannot be naked\"" ]

[]

[ "<s>", "static", "void", "arm_init_bf16_types", "(", "void", ")", "{", "arm_bf16_type_node", "=", "make_node", "(", "REAL_TYPE", ")", ";", "TYPE_PRECISION", "(", "arm_bf16_type_node", ")", "=", "16", ";", "SET_TYPE_MODE", "(", "arm_bf16_type_node", ",", "BFmode", ")", ";", "layout_type", "(", "arm_bf16_type_node", ")", ";", "lang_hooks", ".", "types", ".", "register_builtin_type", "(", "arm_bf16_type_node", ",", "\"__bf16\"", ")", ";", "arm_bf16_ptr_type_node", "=", "build_pointer_type", "(", "arm_bf16_type_node", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "backend", "REAL_TYPE", "type", "supporting", "bfloat", "types", "." ]

[ "arm", "16", "\"__bf16\"" ]

[]

[ "<s>", "void", "NodeAllocator", "::", "clear", "(", ")", "{", "MemPool", ".", "Reset", "(", ")", ";", "Blocks", ".", "clear", "(", ")", ";", "ActiveEnd", "=", "nullptr", ";", "}", "</s>" ]

[ "Clear", "all", "timers", "in", "this", "group", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "rtx", "ix86_expand_sse_cmp", "(", "rtx", "dest", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp_op0", ",", "rtx", "cmp_op1", ",", "rtx", "op_true", ",", "rtx", "op_false", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "machine_mode", "cmp_ops_mode", "=", "GET_MODE", "(", "cmp_op0", ")", ";", "machine_mode", "cmp_mode", ";", "bool", "maskcmp", "=", "false", ";", "rtx", "x", ";", "if", "(", "ix86_use_mask_cmp_p", "(", "mode", ",", "cmp_ops_mode", ",", "op_true", ",", "op_false", ")", ")", "{", "unsigned", "int", "nbits", "=", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ";", "maskcmp", "=", "true", ";", "cmp_mode", "=", "nbits", ">", "8", "?", "int_mode_for_size", "(", "nbits", ",", "0", ")", ".", "require", "(", ")", ":", "E_QImode", ";", "}", "else", "cmp_mode", "=", "cmp_ops_mode", ";", "cmp_op0", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op0", ")", ";", "int", "(", "*", "op1_predicate", ")", "(", "rtx", ",", "machine_mode", ")", "=", "VECTOR_MODE_P", "(", "cmp_ops_mode", ")", "?", "vector_operand", ":", "nonimmediate_operand", ";", "if", "(", "!", "op1_predicate", "(", "cmp_op1", ",", "cmp_ops_mode", ")", ")", "cmp_op1", "=", "force_reg", "(", "cmp_ops_mode", ",", "cmp_op1", ")", ";", "if", "(", "optimize", "||", "(", "maskcmp", "&&", "cmp_mode", "!=", "mode", ")", "||", "(", "op_true", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_true", ")", ")", "||", "(", "op_false", "&&", "reg_overlap_mentioned_p", "(", "dest", ",", "op_false", ")", ")", ")", "dest", "=", "gen_reg_rtx", "(", "maskcmp", "?", "cmp_mode", ":", "mode", ")", ";", "if", "(", "maskcmp", ")", "{", "bool", "ok", "=", "ix86_expand_mask_vec_cmp", "(", "dest", ",", "code", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "gcc_assert", "(", "ok", ")", ";", "return", "dest", ";", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", ")", "{", "x", "=", "force_reg", "(", "cmp_ops_mode", ",", "x", ")", ";", "convert_move", "(", "dest", ",", "x", ",", "false", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "return", "dest", ";", "}", "</s>" ]

[ "Expand", "an", "sse", "vector", "comparison", ".", "Return", "the", "register", "with", "the", "result", "." ]

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

[]

[ "<s>", "tree", "ix86_builtin_vectorized_function", "(", "unsigned", "int", "fn", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "machine_mode", "in_mode", ",", "out_mode", ";", "int", "in_n", ",", "out_n", ";", "if", "(", "TREE_CODE", "(", "type_out", ")", "!=", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type_in", ")", "!=", "VECTOR_TYPE", ")", "return", "NULL_TREE", ";", "out_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "out_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "switch", "(", "fn", ")", "{", "CASE_CFN_IFLOOR", ":", "CASE_CFN_LFLOOR", ":", "if", "(", "flag_trapping_math", "||", "!", "TARGET_SSE4_1", ")", "break", ";", "if", "(", "out_mode", "==", "SImode", "&&", "in_mode", "==", "DFmode", ")", "{", "if", "(", "out_n", "==", "4", "&&", "in_n", "==", "2", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX", ")", ";", "else", "if", "(", "out_n", "==", "8", "&&", "in_n", "==", "4", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX256", ")", ";", "else", "if", "(", "out_n", "==", "16", "&&", "in_n", "==", "8", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX512", ")", ";", "}", "break", ";", "CASE_CFN_ICEIL", ":", "CASE_CFN_LCEIL", ":", "if", "(", "flag_trapping_math", "||", "!", "TARGET_SSE4_1", ")", "break", ";", "if", "(", "out_mode", "==", "SImode", "&&", "in_mode", "==", "DFmode", ")", "{", "if", "(", "out_n", "==", "4", "&&", "in_n", "==", "2", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_CEILPD_VEC_PACK_SFIX", ")", ";", "else", "if", "(", "out_n", "==", "8", "&&", "in_n", "==", "4", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_CEILPD_VEC_PACK_SFIX256", ")", ";", "else", "if", "(", "out_n", "==", "16", "&&", "in_n", "==", "8", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_CEILPD_VEC_PACK_SFIX512", ")", ";", "}", "break", ";", "CASE_CFN_IRINT", ":", "CASE_CFN_LRINT", ":", "if", "(", "out_mode", "==", "SImode", "&&", "in_mode", "==", "DFmode", ")", "{", "if", "(", "out_n", "==", "4", "&&", "in_n", "==", "2", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_VEC_PACK_SFIX", ")", ";", "else", "if", "(", "out_n", "==", "8", "&&", "in_n", "==", "4", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_VEC_PACK_SFIX256", ")", ";", "else", "if", "(", "out_n", "==", "16", "&&", "in_n", "==", "8", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_VEC_PACK_SFIX512", ")", ";", "}", "break", ";", "CASE_CFN_IROUND", ":", "CASE_CFN_LROUND", ":", "if", "(", "flag_trapping_math", "||", "!", "TARGET_SSE4_1", ")", "break", ";", "if", "(", "out_mode", "==", "SImode", "&&", "in_mode", "==", "DFmode", ")", "{", "if", "(", "out_n", "==", "4", "&&", "in_n", "==", "2", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX", ")", ";", "else", "if", "(", "out_n", "==", "8", "&&", "in_n", "==", "4", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX256", ")", ";", "else", "if", "(", "out_n", "==", "16", "&&", "in_n", "==", "8", ")", "return", "ix86_get_builtin", "(", "IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX512", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "if", "(", "ix86_veclib_handler", ")", "return", "ix86_veclib_handler", "(", "combined_fn", "(", "fn", ")", ",", "type_out", ",", "type_in", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Returns", "a", "function", "decl", "for", "a", "vectorized", "version", "of", "the", "builtin", "function", "with", "builtin", "function", "code", "FN", "and", "the", "result", "vector", "type", "TYPE", ",", "or", "NULL_TREE", "if", "it", "is", "not", "available", "." ]

[ "i386", "4", "2", "8", "4", "16", "8", "4", "2", "8", "4", "16", "8", "4", "2", "8", "4", "16", "8", "4", "2", "8", "4", "16", "8" ]

[]

[ "<s>", "bool", "AVRInstrInfo", "::", "isBranchOffsetInRange", "(", "unsigned", "BranchOp", ",", "int64_t", "BrOffset", ")", "const", "{", "switch", "(", "BranchOp", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected opcode!\"", ")", ";", "case", "AVR", "::", "JMPk", ":", "case", "AVR", "::", "CALLk", ":", "return", "true", ";", "case", "AVR", "::", "RCALLk", ":", "case", "AVR", "::", "RJMPk", ":", "return", "isIntN", "(", "13", ",", "BrOffset", ")", ";", "case", "AVR", "::", "BRBSsk", ":", "case", "AVR", "::", "BRBCsk", ":", "case", "AVR", "::", "BREQk", ":", "case", "AVR", "::", "BRNEk", ":", "case", "AVR", "::", "BRSHk", ":", "case", "AVR", "::", "BRLOk", ":", "case", "AVR", "::", "BRMIk", ":", "case", "AVR", "::", "BRPLk", ":", "case", "AVR", "::", "BRGEk", ":", "case", "AVR", "::", "BRLTk", ":", "return", "isIntN", "(", "7", ",", "BrOffset", ")", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "\"unexpected opcode!\"", "AVR::JMPk", "AVR::CALLk", "AVR::RCALLk", "AVR::RJMPk", "13", "AVR::BRBSsk", "AVR::BRBCsk", "AVR::BREQk", "AVR::BRNEk", "AVR::BRSHk", "AVR::BRLOk", "AVR::BRMIk", "AVR::BRPLk", "AVR::BRGEk", "AVR::BRLTk", "7" ]

[]

[ "<s>", "const", "char", "*", "J2TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "J2ISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "J2ISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "J2ISD", "::", "X", ":", "\\", "return", "#", "X", "CASE", "(", "Ret", ")", ";", "CASE", "(", "Call", ")", ";", "CASE", "(", "Wrapper", ")", ";", "CASE", "(", "SHL", ")", ";", "CASE", "(", "SRL", ")", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "J2", "J2", "J2ISD::NodeType", "J2ISD::FIRST_NUMBER", "J2ISD::X" ]

[]

[ "<s>", "bool", "SIPeepholeSDWA", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasSDWA", "(", ")", "||", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "matchSDWAOperands", "(", "MF", ")", ";", "for", "(", "const", "auto", "&", "OperandPair", ":", "SDWAOperands", ")", "{", "const", "auto", "&", "Operand", "=", "OperandPair", ".", "second", ";", "MachineInstr", "*", "PotentialMI", "=", "Operand", "->", "potentialToConvert", "(", "TII", ")", ";", "if", "(", "PotentialMI", "&&", "isConvertibleToSDWA", "(", "*", "PotentialMI", ",", "ST", ")", ")", "{", "PotentialMatches", "[", "PotentialMI", "]", ".", "push_back", "(", "Operand", ".", "get", "(", ")", ")", ";", "}", "}", "for", "(", "auto", "&", "PotentialPair", ":", "PotentialMatches", ")", "{", "MachineInstr", "&", "PotentialMI", "=", "*", "PotentialPair", ".", "first", ";", "convertToSDWA", "(", "PotentialMI", ",", "PotentialPair", ".", "second", ")", ";", "}", "PotentialMatches", ".", "clear", "(", ")", ";", "SDWAOperands", ".", "clear", "(", ")", ";", "bool", "Ret", "=", "!", "ConvertedInstructions", ".", "empty", "(", ")", ";", "while", "(", "!", "ConvertedInstructions", ".", "empty", "(", ")", ")", "legalizeScalarOperands", "(", "*", "ConvertedInstructions", ".", "pop_back_val", "(", ")", ",", "ST", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AVRRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "if", "(", "this", "->", "getRegClass", "(", "AVR", "::", "PTRDISPREGSRegClassID", ")", "->", "hasSubClassEq", "(", "NewRC", ")", ")", "{", "return", "false", ";", "}", "return", "TargetRegisterInfo", "::", "shouldCoalesce", "(", "MI", ",", "SrcRC", ",", "SubReg", ",", "DstRC", ",", "DstSubReg", ",", "NewRC", ",", "LIS", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::PTRDISPREGSRegClassID" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_jump_label_table", "(", ")", "{", "int", "i", ";", "if", "(", "pool_size", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.align 2\\n\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "pool_size", ";", "i", "++", ")", "{", "pool_node", "*", "p", "=", "pool_vector", "+", "i", ";", "ASM_OUTPUT_INTERNAL_LABEL", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "p", "->", "label", ")", ")", ";", "output_asm_insn", "(", "\".long\t%0\"", ",", "&", "p", "->", "value", ")", ";", "}", "pool_size", "=", "0", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Dump", "out", "any", "constants", "accumulated", "in", "the", "final", "pass", ".", "These", "will", "only", "be", "labels", "." ]

[ "mcore", "\"\\t.align 2\\n\"", "0", "\"L\"", "\".long\t%0\"", "0", "\"\"" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "classifyLEAReg", "(", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "Src", ",", "unsigned", "Opc", ",", "bool", "AllowSP", ",", "unsigned", "&", "NewSrc", ",", "bool", "&", "isKill", ",", "bool", "&", "isUndef", ",", "MachineOperand", "&", "ImplicitOp", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "AllowSP", ")", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64RegClass", ":", "&", "X86", "::", "GR32RegClass", ";", "}", "else", "{", "RC", "=", "Opc", "!=", "X86", "::", "LEA32r", "?", "&", "X86", "::", "GR64_NOSPRegClass", ":", "&", "X86", "::", "GR32_NOSPRegClass", ";", "}", "unsigned", "SrcReg", "=", "Src", ".", "getReg", "(", ")", ";", "if", "(", "Opc", "!=", "X86", "::", "LEA64_32r", ")", "{", "NewSrc", "=", "SrcReg", ";", "isKill", "=", "Src", ".", "isKill", "(", ")", ";", "isUndef", "=", "Src", ".", "isUndef", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "NewSrc", ")", "&&", "!", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "NewSrc", ",", "RC", ")", ")", "return", "false", ";", "return", "true", ";", "}", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "SrcReg", ")", ")", "{", "ImplicitOp", "=", "Src", ";", "ImplicitOp", ".", "setImplicit", "(", ")", ";", "NewSrc", "=", "getX86SubSuperRegister", "(", "Src", ".", "getReg", "(", ")", ",", "64", ")", ";", "MachineBasicBlock", "::", "LivenessQueryResult", "LQR", "=", "MI", ".", "getParent", "(", ")", "->", "computeRegisterLiveness", "(", "&", "getRegisterInfo", "(", ")", ",", "NewSrc", ",", "MI", ")", ";", "switch", "(", "LQR", ")", "{", "case", "MachineBasicBlock", "::", "LQR_Unknown", ":", "return", "false", ";", "case", "MachineBasicBlock", "::", "LQR_Live", ":", "isKill", "=", "MI", ".", "killsRegister", "(", "SrcReg", ")", ";", "isUndef", "=", "false", ";", "break", ";", "default", ":", "isKill", "=", "false", ";", "isUndef", "=", "true", ";", "break", ";", "}", "}", "else", "{", "NewSrc", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "RC", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ".", "addReg", "(", "NewSrc", ",", "RegState", "::", "Define", "|", "RegState", "::", "Undef", ",", "X86", "::", "sub_32bit", ")", ".", "addOperand", "(", "Src", ")", ";", "isKill", "=", "true", ";", "isUndef", "=", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Given", "an", "operand", "within", "a", "MachineInstr", ",", "insert", "preceding", "code", "to", "put", "it", "into", "the", "right", "format", "for", "a", "particular", "kind", "of", "LEA", "instruction", "." ]

[ "X86", "X86", "X86::LEA32r", "X86::GR64RegClass", "X86::GR32RegClass", "X86::LEA32r", "X86::GR64_NOSPRegClass", "X86::GR32_NOSPRegClass", "X86::LEA64_32r", "X86", "64", "X86::sub_32bit" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", "||", "RC", "==", "ARM", "::", "tGPRRegisterClass", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegisterClass", "ARM::tGPRRegisterClass", "0", "ARM::t2LDRi12", "0", "ARM" ]

[]

[ "<s>", "char", "*", "iq2000_output_conditional_branch", "(", "rtx", "insn", ",", "rtx", "*", "operands", ",", "int", "two_operands_p", ",", "int", "float_p", ",", "int", "inverted_p", ",", "int", "length", ")", "{", "static", "char", "buffer", "[", "200", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "int", "need_z_p", ";", "const", "char", "*", "op1", "=", "\"%z2\"", ";", "const", "char", "*", "op2", "=", "(", "two_operands_p", "?", "\",%z3\"", ":", "\",%.\"", ")", ";", "const", "char", "*", "comp", "=", "(", "float_p", "?", "\"%F0\"", ":", "\"%C0\"", ")", ";", "const", "char", "*", "inverted_comp", "=", "(", "float_p", "?", "\"%W0\"", ":", "\"%N0\"", ")", ";", "iq2000_branch_likely", "=", "(", "final_sequence", "&&", "INSN_ANNULLED_BRANCH_P", "(", "insn", ")", ")", ";", "if", "(", "!", "two_operands_p", ")", "{", "switch", "(", "code", ")", "{", "case", "GTU", ":", "code", "=", "NE", ";", "break", ";", "case", "LEU", ":", "code", "=", "EQ", ";", "break", ";", "case", "GEU", ":", "code", "=", "EQ", ";", "op1", "=", "\"%.\"", ";", "break", ";", "case", "LTU", ":", "code", "=", "NE", ";", "op1", "=", "\"%.\"", ";", "break", ";", "default", ":", "break", ";", "}", "}", "need_z_p", "=", "(", "!", "float_p", "&&", "code", "!=", "EQ", "&&", "code", "!=", "NE", ")", ";", "if", "(", "need_z_p", ")", "op2", "=", "\"\"", ";", "buffer", "[", "0", "]", "=", "'\\0'", ";", "switch", "(", "length", ")", "{", "case", "4", ":", "case", "8", ":", "if", "(", "float_p", ")", "sprintf", "(", "buffer", ",", "\"b%s%%?\\t%%Z2%%1\"", ",", "inverted_p", "?", "inverted_comp", ":", "comp", ")", ";", "else", "sprintf", "(", "buffer", ",", "\"b%s%s%%?\\t%s%s,%%1\"", ",", "inverted_p", "?", "inverted_comp", ":", "comp", ",", "need_z_p", "?", "\"z\"", ":", "\"\"", ",", "op1", ",", "op2", ")", ";", "return", "buffer", ";", "case", "12", ":", "case", "16", ":", "{", "const", "char", "*", "target", "=", "(", "(", "iq2000_branch_likely", "||", "length", "==", "16", ")", "?", "\".+16\"", ":", "\".+12\"", ")", ";", "char", "*", "c", ";", "c", "=", "strchr", "(", "buffer", ",", "'\\0'", ")", ";", "if", "(", "float_p", ")", "sprintf", "(", "c", ",", "\"b%s\\t%%Z2%s\"", ",", "inverted_p", "?", "comp", ":", "inverted_comp", ",", "target", ")", ";", "else", "sprintf", "(", "c", ",", "\"b%s%s\\t%s%s,%s\"", ",", "inverted_p", "?", "comp", ":", "inverted_comp", ",", "need_z_p", "?", "\"z\"", ":", "\"\"", ",", "op1", ",", "op2", ",", "target", ")", ";", "strcat", "(", "c", ",", "\"\\n\\tnop\\n\\tj\\t%1\"", ")", ";", "if", "(", "length", "==", "16", ")", "strcat", "(", "buffer", ",", "\"\\n\\tnop\"", ")", ";", "return", "buffer", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Output", "assembly", "instructions", "to", "perform", "a", "conditional", "branch", ".", "INSN", "is", "the", "branch", "instruction", ".", "OPERANDS", "[", "0", "]", "is", "the", "condition", ".", "OPERANDS", "[", "1", "]", "is", "the", "target", "of", "the", "branch", ".", "OPERANDS", "[", "2", "]", "is", "the", "target", "of", "the", "first", "operand", "to", "the", "condition", ".", "If", "TWO_OPERANDS_P", "is", "nonzero", "the", "comparison", "takes", "two", "operands", ";", "OPERANDS", "[", "3", "]", "will", "be", "the", "second", "operand", ".", "If", "INVERTED_P", "is", "nonzero", "we", "are", "to", "branch", "if", "the", "condition", "does", "not", "hold", ".", "If", "FLOAT_P", "is", "nonzero", "this", "is", "a", "floating-point", "comparison", ".", "LENGTH", "is", "the", "length", "(", "in", "bytes", ")", "of", "the", "sequence", "we", "are", "to", "generate", ".", "That", "tells", "us", "whether", "to", "generate", "a", "simple", "conditional", "branch", ",", "or", "a", "reversed", "conditional", "branch", "around", "a", "`", "jr", "'", "instruction", "." ]

[ "iq2000", "200", "0", "\"%z2\"", "\",%z3\"", "\",%.\"", "\"%F0\"", "\"%C0\"", "\"%W0\"", "\"%N0\"", "\"%.\"", "\"%.\"", "\"\"", "0", "4", "8", "\"b%s%%?\\t%%Z2%%1\"", "\"b%s%s%%?\\t%s%s,%%1\"", "\"z\"", "\"\"", "12", "16", "16", "\".+16\"", "\".+12\"", "\"b%s\\t%%Z2%s\"", "\"b%s%s\\t%s%s,%s\"", "\"z\"", "\"\"", "\"\\n\\tnop\\n\\tj\\t%1\"", "16", "\"\\n\\tnop\"", "0" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCVABI", "::", "getBPReg", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VL", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "VTYPE", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "0", "RISCV", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8", "RISCVABI::getBPReg", "RISCV::VL", "RISCV::VTYPE" ]

[]

[ "<s>", "SDValue", "Z80oldTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "switch", "(", "N", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "return", "combineExtractSubreg", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "MUL", ":", "return", "combineMul", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "combineAnd", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZeroExtend", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "combineTruncate", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "Z80oldISD", "::", "SUB", ":", "return", "combineSub", "(", "N", ",", "DCI", ")", ";", "case", "Z80oldISD", "::", "SEXT", ":", "return", "combineSExt", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "Z80old", "Z80old", "ISD::MUL", "ISD::AND", "ISD::ZERO_EXTEND", "ISD::TRUNCATE", "Z80oldISD::SUB", "Z80oldISD::SEXT" ]

[]

[ "<s>", "bool", "AVRAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Error", "=", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ";", "if", "(", "Error", "&&", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "if", "(", "ExtraCode", "[", "0", "]", ">=", "'A'", "&&", "ExtraCode", "[", "0", "]", "<=", "'Z'", ")", "{", "const", "MachineOperand", "&", "RegOp", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "RegOp", ".", "isReg", "(", ")", "&&", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", ")", ";", "Register", "Reg", "=", "RegOp", ".", "getReg", "(", ")", ";", "unsigned", "ByteNumber", "=", "ExtraCode", "[", "0", "]", "-", "'A'", ";", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "(", "void", ")", "NumOpRegs", ";", "const", "AVRSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "BytesPerReg", "=", "TRI", ".", "getRegSizeInBits", "(", "*", "RC", ")", "/", "8", ";", "assert", "(", "BytesPerReg", "<=", "2", "&&", "\"Only 8 and 16 bit regs are supported.\"", ")", ";", "unsigned", "RegIdx", "=", "ByteNumber", "/", "BytesPerReg", ";", "assert", "(", "RegIdx", "<", "NumOpRegs", "&&", "\"Multibyte index out of range.\"", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "RegIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "BytesPerReg", "==", "2", ")", "{", "Reg", "=", "TRI", ".", "getSubReg", "(", "Reg", ",", "ByteNumber", "%", "BytesPerReg", "?", "AVR", "::", "sub_hi", ":", "AVR", "::", "sub_lo", ")", ";", "}", "O", "<<", "AVRInstPrinter", "::", "getPrettyRegisterName", "(", "Reg", ",", "MRI", ")", ";", "return", "false", ";", "}", "}", "if", "(", "Error", ")", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "0", "1", "0", "0", "0", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", "0", "1", "AVR", "AVR", "8", "2", "\"Only 8 and 16 bit regs are supported.\"", "\"Multibyte index out of range.\"", "2", "AVR::sub_hi", "AVR::sub_lo", "AVR" ]

[]

[ "<s>", "X86DCBasicBlock", "&", "getParent", "(", ")", "{", "return", "static_cast", "<", "X86DCBasicBlock", "&", ">", "(", "DCInstruction", "::", "getParent", "(", ")", ")", ";", "}", "</s>" ]

[ "getParent", "-", "Return", "the", "last", "analyzed", "interval", "." ]

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

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "DAG", "->", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getCPUDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", ")", "return", "new", "PPCDispatchGroupSBHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "if", "(", "Directive", "!=", "PPC", "::", "DIR_440", "&&", "Directive", "!=", "PPC", "::", "DIR_A2", "&&", "Directive", "!=", "PPC", "::", "DIR_E500mc", "&&", "Directive", "!=", "PPC", "::", "DIR_E5500", ")", "{", "assert", "(", "DAG", "->", "TII", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "DAG", ")", ";", "}", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "\"No InstrInfo?\"", "PPC" ]

[]

[ "<s>", "const", "char", "*", "output_call", "(", "rtx", "x", ")", "{", "if", "(", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "m68k_symbolic_call", ";", "else", "return", "\"jsr %a0\"", ";", "}", "</s>" ]

[ "INSN", "is", "either", "a", "function", "call", "or", "a", "millicode", "call", ".", "It", "may", "have", "an", "unconditional", "jump", "in", "its", "delay", "slot", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]

[ "m68k", "\"jsr %a0\"" ]

[]

[ "<s>", "unsigned", "PPCFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ",", "bool", "UpdateMF", ",", "bool", "UseEstimate", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "UseEstimate", "?", "MFI", "->", "estimateStackSize", "(", "MF", ")", ":", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "TargetAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "std", "::", "max", "(", "MaxAlign", ",", "TargetAlign", ")", "-", "1", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "PPCRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "bool", "DisableRedZone", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoRedZone", ")", ";", "if", "(", "!", "DisableRedZone", "&&", "(", "Subtarget", ".", "isPPC64", "(", ")", "||", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", "||", "FrameSize", "==", "0", ")", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", "0", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isDarwinABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "if", "(", "UpdateMF", ")", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "return", "FrameSize", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "PPC", "PPC", "PPC", "0", "224", "0", "0", "PPC" ]

[]

[ "<s>", "void", "msp430_expand_eh_return", "(", "rtx", "eh_handler", ")", "{", "rtx", "ap", ",", "sa", ",", "ra", ",", "tmp", ";", "ap", "=", "arg_pointer_rtx", ";", "sa", "=", "msp430_eh_return_stackadj_rtx", "(", ")", ";", "ra", "=", "eh_handler", ";", "tmp", "=", "ap", ";", "tmp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "ap", ",", "sa", ")", ";", "tmp", "=", "plus_constant", "(", "Pmode", ",", "tmp", ",", "TARGET_LARGE", "?", "-", "4", ":", "-", "2", ")", ";", "tmp", "=", "gen_rtx_MEM", "(", "Pmode", ",", "tmp", ")", ";", "emit_move_insn", "(", "tmp", ",", "ra", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "before", "reload", ",", "to", "``", "fix", "''", "the", "stack", "in", "preparation", "for", "an", "EH", "return", "." ]

[ "msp430", "4", "2" ]

[]

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

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

[ "Lanai" ]

[]

[ "<s>", "void", "UnwindOpcodeAssembler", "::", "EmitVFPRegSave", "(", "uint32_t", "VFPRegSave", ")", "{", "size_t", "i", "=", "32", ";", "while", "(", "i", ">", "16", ")", "{", "uint32_t", "Bit", "=", "1u", "<<", "(", "i", "-", "1", ")", ";", "if", "(", "(", "VFPRegSave", "&", "Bit", ")", "==", "0u", ")", "{", "--", "i", ";", "continue", ";", "}", "uint32_t", "Range", "=", "0", ";", "--", "i", ";", "Bit", ">>=", "1", ";", "while", "(", "i", ">", "16", "&&", "(", "VFPRegSave", "&", "Bit", ")", ")", "{", "--", "i", ";", "++", "Range", ";", "Bit", ">>=", "1", ";", "}", "EmitInt16", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_VFP_REG_RANGE_FSTMFDD_D16", "|", "(", "(", "i", "-", "16", ")", "<<", "4", ")", "|", "Range", ")", ";", "}", "while", "(", "i", ">", "0", ")", "{", "uint32_t", "Bit", "=", "1u", "<<", "(", "i", "-", "1", ")", ";", "if", "(", "(", "VFPRegSave", "&", "Bit", ")", "==", "0u", ")", "{", "--", "i", ";", "continue", ";", "}", "uint32_t", "Range", "=", "0", ";", "--", "i", ";", "Bit", ">>=", "1", ";", "while", "(", "i", ">", "0", "&&", "(", "VFPRegSave", "&", "Bit", ")", ")", "{", "--", "i", ";", "++", "Range", ";", "Bit", ">>=", "1", ";", "}", "EmitInt16", "(", "ARM", "::", "EHABI", "::", "UNWIND_OPCODE_POP_VFP_REG_RANGE_FSTMFDD", "|", "(", "i", "<<", "4", ")", "|", "Range", ")", ";", "}", "}", "</s>" ]

[ "Emit", "unwind", "opcodes", "for", ".vsave", "directives", "." ]

[ "ARM", "32", "16", "1u", "1", "0u", "0", "1", "16", "1", "ARM::EHABI", "16", "4", "0", "1u", "1", "0u", "0", "1", "0", "1", "ARM::EHABI", "4" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "ReserveX18", "(", "AArch64", "::", "isX18ReservedByDefault", "(", "TT", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "static_cast", "<", "const", "AArch64TargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::isX18ReservedByDefault", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

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

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

[ "X86", "X86", "X86::VR128XRegClass", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "static", "rtx", "tilegx_function_value", "(", "const_tree", "valtype", ",", "const_tree", "fn_decl_or_type", ",", "bool", "outgoing", "ATTRIBUTE_UNUSED", ")", "{", "machine_mode", "mode", ";", "int", "unsigned_p", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsigned_p", ",", "fn_decl_or_type", ",", "1", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "0", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_VALUE", "." ]

[ "tilegx", "1", "0" ]

[]

[ "<s>", "static", "int", "arc600_corereg_hazard", "(", "rtx_insn", "*", "pred", ",", "rtx_insn", "*", "succ", ")", "{", "if", "(", "!", "TARGET_ARC600", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "pred", ")", ")", "==", "SEQUENCE", ")", "pred", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "pred", ")", ")", "->", "insn", "(", "1", ")", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "succ", ")", ")", "==", "SEQUENCE", ")", "succ", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "succ", ")", ")", "->", "insn", "(", "0", ")", ";", "if", "(", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mulsi_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umul_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mac_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mul64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_mac64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umul64_600", "||", "recog_memoized", "(", "pred", ")", "==", "CODE_FOR_umac64_600", ")", "return", "0", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "pred", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SET", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "break", ";", "default", ":", "continue", ";", "}", "rtx", "dest", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", ">=", "32", "&&", "REGNO", "(", "dest", ")", "<", "61", "&&", "(", "refers_to_regno_p", "(", "REGNO", "(", "dest", ")", ",", "REGNO", "(", "dest", ")", "+", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "dest", ")", ")", "+", "3", ")", "/", "4U", ",", "PATTERN", "(", "succ", ")", ",", "0", ")", ")", ")", "return", "4", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "length", "adjustment", "for", "INSN", ".", "For", "ARC600", ":", "A", "write", "to", "a", "core", "reg", "greater", "or", "equal", "to", "32", "must", "not", "be", "immediately", "followed", "by", "a", "use", ".", "Anticipate", "the", "length", "requirement", "to", "insert", "a", "nop", "between", "PRED", "and", "SUCC", "to", "prevent", "a", "hazard", "." ]

[ "arc", "0", "1", "0", "0", "0", "32", "61", "3", "4U", "0", "4", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_movw_imm", "(", "HOST_WIDE_INT", "val", ",", "scalar_int_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "4", ")", "{", "if", "(", "(", "val", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "0xffff", ")", "<<", "32", ")", ")", "==", "val", "||", "(", "val", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "0xffff", ")", "<<", "48", ")", ")", "==", "val", ")", "return", "1", ";", "}", "else", "{", "val", "&=", "(", "HOST_WIDE_INT", ")", "0xffffffff", ";", "}", "return", "(", "(", "val", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "0xffff", ")", "<<", "0", ")", ")", "==", "val", "||", "(", "val", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "0xffff", ")", "<<", "16", ")", ")", "==", "val", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "val", "is", "an", "immediate", "that", "can", "be", "loaded", "into", "a", "register", "by", "a", "MOVZ", "instruction", "." ]

[ "aarch64", "4", "0xffff", "32", "0xffff", "48", "1", "0xffffffff", "0xffff", "0", "0xffff", "16" ]

[]

[ "<s>", "void", "arc_init", "(", "void", ")", "{", "enum", "attr_tune", "tune_dflt", "=", "TUNE_NONE", ";", "if", "(", "TARGET_A5", ")", "{", "arc_cpu_string", "=", "\"A5\"", ";", "}", "else", "if", "(", "TARGET_ARC600", ")", "{", "arc_cpu_string", "=", "\"ARC600\"", ";", "tune_dflt", "=", "TUNE_ARC600", ";", "}", "else", "if", "(", "TARGET_ARC601", ")", "{", "arc_cpu_string", "=", "\"ARC601\"", ";", "tune_dflt", "=", "TUNE_ARC600", ";", "}", "else", "if", "(", "TARGET_ARC700", ")", "{", "arc_cpu_string", "=", "\"ARC700\"", ";", "tune_dflt", "=", "TUNE_ARC700_4_2_STD", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "arc_tune", "==", "TUNE_NONE", ")", "arc_tune", "=", "tune_dflt", ";", "if", "(", "arc_multcost", "<", "0", ")", "switch", "(", "arc_tune", ")", "{", "case", "TUNE_ARC700_4_2_STD", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC700_4_2_XMAC", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "3", ")", ";", "if", "(", "TARGET_NOMPY_SET", ")", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "case", "TUNE_ARC600", ":", "if", "(", "TARGET_MUL64_SET", ")", "{", "arc_multcost", "=", "COSTS_N_INSNS", "(", "4", ")", ";", "break", ";", "}", "default", ":", "arc_multcost", "=", "COSTS_N_INSNS", "(", "30", ")", ";", "break", ";", "}", "if", "(", "TARGET_MUL64_SET", "&&", "TARGET_ARC700", ")", "error", "(", "\"-mmul64 not supported for ARC700\"", ")", ";", "if", "(", "TARGET_NOMPY_SET", "&&", "!", "TARGET_ARC700", ")", "error", "(", "\"-mno-mpy supported only for ARC700\"", ")", ";", "if", "(", "TARGET_MULMAC_32BY16_SET", "&&", "!", "(", "TARGET_ARC600", "||", "TARGET_ARC601", ")", ")", "error", "(", "\"-mmul32x16 supported only for ARC600 or ARC601\"", ")", ";", "if", "(", "!", "TARGET_DPFP", "&&", "TARGET_DPFP_DISABLE_LRSR", ")", "error", "(", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", ")", ";", "if", "(", "(", "TARGET_DPFP_FAST_SET", "&&", "TARGET_DPFP_COMPACT_SET", ")", "||", "(", "TARGET_SPFP_FAST_SET", "&&", "TARGET_SPFP_COMPACT_SET", ")", ")", "error", "(", "\"FPX fast and compact options cannot be specified together\"", ")", ";", "if", "(", "TARGET_SPFP_FAST_SET", "&&", "(", "TARGET_ARC600", "||", "TARGET_ARC601", ")", ")", "error", "(", "\"-mspfp_fast not available on ARC600 or ARC601\"", ")", ";", "if", "(", "(", "TARGET_DPFP", "||", "TARGET_SPFP", ")", "&&", "!", "(", "TARGET_ARC600", "||", "TARGET_ARC601", "||", "TARGET_ARC700", ")", ")", "error", "(", "\"FPX extensions not available on pre-ARC600 cores\"", ")", ";", "if", "(", "flag_pic", "&&", "!", "TARGET_ARC700", ")", "{", "warning", "(", "DK_WARNING", ",", "\"PIC is not supported for %s. Generating non-PIC code only..\"", ",", "arc_cpu_string", ")", ";", "flag_pic", "=", "0", ";", "}", "arc_init_reg_tables", "(", ")", ";", "memset", "(", "arc_punct_chars", ",", "0", ",", "sizeof", "(", "arc_punct_chars", ")", ")", ";", "arc_punct_chars", "[", "'#'", "]", "=", "1", ";", "arc_punct_chars", "[", "'*'", "]", "=", "1", ";", "arc_punct_chars", "[", "'?'", "]", "=", "1", ";", "arc_punct_chars", "[", "'!'", "]", "=", "1", ";", "arc_punct_chars", "[", "'^'", "]", "=", "1", ";", "arc_punct_chars", "[", "'&'", "]", "=", "1", ";", "if", "(", "optimize", ">", "1", "&&", "!", "TARGET_NO_COND_EXEC", ")", "{", "opt_pass", "*", "pass_arc_ifcvt_4", "=", "make_pass_arc_ifcvt", "(", "g", ")", ";", "struct", "register_pass_info", "arc_ifcvt4_info", "=", "{", "pass_arc_ifcvt_4", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "struct", "register_pass_info", "arc_ifcvt5_info", "=", "{", "pass_arc_ifcvt_4", "->", "clone", "(", ")", ",", "\"shorten\"", ",", "1", ",", "PASS_POS_INSERT_BEFORE", "}", ";", "register_pass", "(", "&", "arc_ifcvt4_info", ")", ";", "register_pass", "(", "&", "arc_ifcvt5_info", ")", ";", "}", "if", "(", "flag_delayed_branch", ")", "{", "opt_pass", "*", "pass_arc_predicate_delay_insns", "=", "make_pass_arc_predicate_delay_insns", "(", "g", ")", ";", "struct", "register_pass_info", "arc_predicate_delay_info", "=", "{", "pass_arc_predicate_delay_insns", ",", "\"dbr\"", ",", "1", ",", "PASS_POS_INSERT_AFTER", "}", ";", "register_pass", "(", "&", "arc_predicate_delay_info", ")", ";", "}", "}", "</s>" ]

[ "Called", "by", "OVERRIDE_OPTIONS", "to", "initialize", "various", "things", "." ]

[ "arc", "\"A5\"", "\"ARC600\"", "\"ARC601\"", "\"ARC700\"", "0", "4", "30", "3", "30", "4", "30", "\"-mmul64 not supported for ARC700\"", "\"-mno-mpy supported only for ARC700\"", "\"-mmul32x16 supported only for ARC600 or ARC601\"", "\"-mno-dpfp-lrsr supported only with -mdpfp\"", "\"FPX fast and compact options cannot be specified together\"", "\"-mspfp_fast not available on ARC600 or ARC601\"", "\"FPX extensions not available on pre-ARC600 cores\"", "\"PIC is not supported for %s. Generating non-PIC code only..\"", "0", "0", "1", "1", "1", "1", "1", "1", "1", "\"dbr\"", "1", "\"shorten\"", "1", "\"dbr\"", "1" ]

[]

[ "<s>", "const", "char", "*", "MOSMCExpr", "::", "getName", "(", ")", "const", "{", "const", "auto", "&", "Modifier", "=", "std", "::", "find_if", "(", "std", "::", "begin", "(", "ModifierNames", ")", ",", "std", "::", "end", "(", "ModifierNames", ")", ",", "[", "this", "]", "(", "ModifierEntry", "const", "&", "Mod", ")", "{", "return", "Mod", ".", "VariantKind", "==", "Kind", ";", "}", ")", ";", "if", "(", "Modifier", "!=", "std", "::", "end", "(", "ModifierNames", ")", ")", "{", "return", "Modifier", "->", "Spelling", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "MOS", "MOS" ]

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", ";", "if", "(", "Constraint", ".", "size", "(", ")", "!=", "1", ")", "return", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'Z'", ":", "{", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ";", "if", "(", "!", "C", ")", "return", ";", "uint64_t", "CVal", "=", "C", "->", "getZExtValue", "(", ")", ";", "uint32_t", "Bits", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unimplemented C_Other constraint\"", ")", ";", "case", "'I'", ":", "if", "(", "CVal", "<=", "0xfff", ")", "break", ";", "return", ";", "case", "'K'", ":", "if", "(", "A64Imms", "::", "isLogicalImm", "(", "32", ",", "CVal", ",", "Bits", ")", ")", "break", ";", "return", ";", "case", "'L'", ":", "if", "(", "A64Imms", "::", "isLogicalImm", "(", "64", ",", "CVal", ",", "Bits", ")", ")", "break", ";", "return", ";", "case", "'Z'", ":", "if", "(", "CVal", "==", "0", ")", "break", ";", "return", ";", "}", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CVal", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "case", "'S'", ":", "{", "if", "(", "const", "GlobalAddressSDNode", "*", "GA", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetGlobalAddress", "(", "GA", "->", "getGlobal", "(", ")", ",", "SDLoc", "(", "Op", ")", ",", "GA", "->", "getValueType", "(", "0", ")", ")", ";", "}", "else", "if", "(", "const", "BlockAddressSDNode", "*", "BA", "=", "dyn_cast", "<", "BlockAddressSDNode", ">", "(", "Op", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetBlockAddress", "(", "BA", "->", "getBlockAddress", "(", ")", ",", "BA", "->", "getValueType", "(", "0", ")", ")", ";", "}", "else", "if", "(", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Op", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetExternalSymbol", "(", "ES", "->", "getSymbol", "(", ")", ",", "ES", "->", "getValueType", "(", "0", ")", ")", ";", "}", "else", "return", ";", "break", ";", "}", "case", "'Y'", ":", "if", "(", "const", "ConstantFPSDNode", "*", "CFP", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "CFP", "->", "isExactlyValue", "(", "0.0", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstantFP", "(", "0.0", ",", "CFP", "->", "getValueType", "(", "0", ")", ")", ";", "break", ";", "}", "}", "return", ";", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "AArch64", "AArch64", "1", "0", "0", "\"Unimplemented C_Other constraint\"", "0xfff", "32", "64", "0", "0", "0", "0", "0.0", "0.0", "0" ]

[]

[ "<s>", "rtx", "arc_rewrite_small_data", "(", "rtx", "op", ")", "{", "op", "=", "copy_insn", "(", "op", ")", ";", "subrtx_ptr_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX_PTR", "(", "iter", ",", "array", ",", "&", "op", ",", "ALL", ")", "{", "rtx", "*", "loc", "=", "*", "iter", ";", "if", "(", "arc_rewrite_small_data_p", "(", "*", "loc", ")", ")", "{", "gcc_assert", "(", "SDATA_BASE_REGNUM", "==", "PIC_OFFSET_TABLE_REGNUM", ")", ";", "*", "loc", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "*", "loc", ")", ";", "if", "(", "loc", "!=", "&", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "&", "XEXP", "(", "op", ",", "0", ")", "==", "loc", ")", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "MULT", ")", "*", "loc", "=", "force_reg", "(", "Pmode", ",", "*", "loc", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "*", "loc", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "*", "loc", ",", "0", ")", ",", "pic_offset_table_rtx", ")", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "op", ";", "}", "</s>" ]

[ "If", "possible", ",", "rewrite", "OP", "so", "that", "it", "refers", "to", "small", "data", "using", "explicit", "relocations", "." ]

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

[]

[ "<s>", "bool", "WebAssemblyAddMissingPrototypes", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Add Missing Prototypes **********\\n\"", ")", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "Function", "*", ",", "Function", "*", ">>", "Replacements", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", "||", "!", "F", ".", "hasFnAttribute", "(", "\"no-prototype\"", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found no-prototype function: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "F", ".", "isVarArg", "(", ")", ")", "report_fatal_error", "(", "\"Functions with 'no-prototype' attribute must take varargs: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "if", "(", "F", ".", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "!=", "0", ")", "report_fatal_error", "(", "\"Functions with 'no-prototype' attribute should not have params: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "FunctionType", "*", "NewType", "=", "nullptr", ";", "Function", "*", "NewF", "=", "nullptr", ";", "for", "(", "Use", "&", "U", ":", "F", ".", "uses", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"prototype-less use: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "auto", "*", "BC", "=", "dyn_cast", "<", "BitCastOperator", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "if", "(", "auto", "*", "DestType", "=", "dyn_cast", "<", "FunctionType", ">", "(", "BC", "->", "getDestTy", "(", ")", "->", "getPointerElementType", "(", ")", ")", ")", "{", "if", "(", "!", "NewType", ")", "{", "NewType", "=", "DestType", ";", "NewF", "=", "Function", "::", "Create", "(", "NewType", ",", "F", ".", "getLinkage", "(", ")", ",", "F", ".", "getName", "(", ")", "+", "\".fixed_sig\"", ")", ";", "NewF", "->", "setAttributes", "(", "F", ".", "getAttributes", "(", ")", ")", ";", "NewF", "->", "removeFnAttr", "(", "\"no-prototype\"", ")", ";", "Replacements", ".", "emplace_back", "(", "&", "F", ",", "NewF", ")", ";", "}", "else", "{", "if", "(", "NewType", "!=", "DestType", ")", "{", "report_fatal_error", "(", "\"Prototypeless function used with \"", "\"conflicting signatures: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "}", "}", "}", "}", "}", "if", "(", "!", "NewType", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"could not derive a function prototype from usage: \"", "+", "F", ".", "getName", "(", ")", "+", "\"\\n\"", ")", ";", "continue", ";", "}", "}", "for", "(", "auto", "&", "Pair", ":", "Replacements", ")", "{", "Function", "*", "OldF", "=", "Pair", ".", "first", ";", "Function", "*", "NewF", "=", "Pair", ".", "second", ";", "std", "::", "string", "Name", "=", "OldF", "->", "getName", "(", ")", ";", "M", ".", "getFunctionList", "(", ")", ".", "push_back", "(", "NewF", ")", ";", "OldF", "->", "replaceAllUsesWith", "(", "ConstantExpr", "::", "getPointerBitCastOrAddrSpaceCast", "(", "NewF", ",", "OldF", "->", "getType", "(", ")", ")", ")", ";", "OldF", "->", "eraseFromParent", "(", ")", ";", "NewF", "->", "setName", "(", "Name", ")", ";", "}", "return", "!", "Replacements", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Add Missing Prototypes **********\\n\"", "\"no-prototype\"", "\"Found no-prototype function: \"", "\"\\n\"", "\"Functions with 'no-prototype' attribute must take varargs: \"", "0", "\"Functions with 'no-prototype' attribute should not have params: \"", "\"prototype-less use: \"", "\"\\n\"", "\".fixed_sig\"", "\"no-prototype\"", "\"Prototypeless function used with \"", "\"conflicting signatures: \"", "\"could not derive a function prototype from usage: \"", "\"\\n\"" ]

[]

[ "<s>", "CCAssignFn", "*", "AArch64TargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "WebKit_JS", ":", "return", "CC_AArch64_WebKit_JS", ";", "case", "CallingConv", "::", "GHC", ":", "return", "CC_AArch64_GHC", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "PreserveMost", ":", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "case", "CallingConv", "::", "Swift", ":", "if", "(", "Subtarget", "->", "isTargetWindows", "(", ")", "&&", "IsVarArg", ")", "return", "CC_AArch64_Win64_VarArg", ";", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_AArch64_AAPCS", ";", "return", "IsVarArg", "?", "CC_AArch64_DarwinPCS_VarArg", ":", "CC_AArch64_DarwinPCS", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Unsupported calling convention.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "bool", "aarch64_pass_by_reference", "(", "cumulative_args_t", "pcum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "size", ";", "machine_mode", "dummymode", ";", "int", "nregs", ";", "if", "(", "mode", "==", "BLKmode", "&&", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "if", "(", "size", "<", "0", ")", "return", "true", ";", "if", "(", "aarch64_vfp_is_call_or_return_candidate", "(", "mode", ",", "type", ",", "&", "dummymode", ",", "&", "nregs", ",", "NULL", ")", ")", "return", "false", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_PASS_BY_REFERENCE", "." ]

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

[]

[ "<s>", "static", "void", "setup_incoming_varargs_64", "(", "CUMULATIVE_ARGS", "*", "cum", ")", "{", "rtx", "save_area", ",", "mem", ";", "alias_set_type", "set", ";", "int", "i", ",", "max", ";", "if", "(", "cfun", "->", "va_list_gpr_size", ")", "ix86_varargs_gpr_size", "=", "X86_64_REGPARM_MAX", "*", "UNITS_PER_WORD", ";", "else", "ix86_varargs_gpr_size", "=", "0", ";", "if", "(", "TARGET_SSE", "&&", "cfun", "->", "va_list_fpr_size", ")", "ix86_varargs_fpr_size", "=", "X86_64_SSE_REGPARM_MAX", "*", "16", ";", "else", "ix86_varargs_fpr_size", "=", "0", ";", "if", "(", "!", "ix86_varargs_gpr_size", "&&", "!", "ix86_varargs_fpr_size", ")", "return", ";", "save_area", "=", "frame_pointer_rtx", ";", "set", "=", "get_varargs_alias_set", "(", ")", ";", "max", "=", "cum", "->", "regno", "+", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "if", "(", "max", ">", "X86_64_REGPARM_MAX", ")", "max", "=", "X86_64_REGPARM_MAX", ";", "for", "(", "i", "=", "cum", "->", "regno", ";", "i", "<", "max", ";", "i", "++", ")", "{", "mem", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "Pmode", ",", "save_area", ",", "i", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "word_mode", ",", "x86_64_int_parameter_registers", "[", "i", "]", ")", ")", ";", "}", "if", "(", "ix86_varargs_fpr_size", ")", "{", "machine_mode", "smode", ";", "rtx_code_label", "*", "label", ";", "rtx", "test", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "test", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "QImode", ",", "AX_REG", ")", ",", "const0_rtx", ")", ";", "emit_jump_insn", "(", "gen_cbranchqi4", "(", "test", ",", "XEXP", "(", "test", ",", "0", ")", ",", "XEXP", "(", "test", ",", "1", ")", ",", "label", ")", ")", ";", "smode", "=", "V4SFmode", ";", "if", "(", "crtl", "->", "stack_alignment_needed", "<", "GET_MODE_ALIGNMENT", "(", "smode", ")", ")", "crtl", "->", "stack_alignment_needed", "=", "GET_MODE_ALIGNMENT", "(", "smode", ")", ";", "max", "=", "cum", "->", "sse_regno", "+", "cfun", "->", "va_list_fpr_size", "/", "16", ";", "if", "(", "max", ">", "X86_64_SSE_REGPARM_MAX", ")", "max", "=", "X86_64_SSE_REGPARM_MAX", ";", "for", "(", "i", "=", "cum", "->", "sse_regno", ";", "i", "<", "max", ";", "++", "i", ")", "{", "mem", "=", "plus_constant", "(", "Pmode", ",", "save_area", ",", "i", "*", "16", "+", "ix86_varargs_gpr_size", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "smode", ",", "mem", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "set_mem_align", "(", "mem", ",", "GET_MODE_ALIGNMENT", "(", "smode", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "smode", ",", "GET_SSE_REGNO", "(", "i", ")", ")", ")", ";", "}", "emit_label", "(", "label", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "h8300_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "if", "(", "TARGET_H8300H", ")", "fputs", "(", "TARGET_NORMAL_MODE", "?", "\"\\t.h8300hn\\n\"", ":", "\"\\t.h8300h\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_H8300SX", ")", "fputs", "(", "TARGET_NORMAL_MODE", "?", "\"\\t.h8300sxn\\n\"", ":", "\"\\t.h8300sx\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_H8300S", ")", "fputs", "(", "TARGET_NORMAL_MODE", "?", "\"\\t.h8300sn\\n\"", ":", "\"\\t.h8300s\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "code", "for", "the", "start", "of", "the", "file", "." ]

[ "h8300", "\"\\t.h8300hn\\n\"", "\"\\t.h8300h\\n\"", "\"\\t.h8300sxn\\n\"", "\"\\t.h8300sx\\n\"", "\"\\t.h8300sn\\n\"", "\"\\t.h8300s\\n\"" ]

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createAMDGPUConvertToISAPass", "(", "*", "TM", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "R600" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "AMDGPUMCInstLower", "MCInstLowering", "(", "OutContext", ",", "MF", "->", "getTarget", "(", ")", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ")", ";", "StringRef", "Err", ";", "if", "(", "!", "TM", ".", "getInstrInfo", "(", ")", "->", "verifyInstruction", "(", "MI", ",", "Err", ")", ")", "{", "errs", "(", ")", "<<", "\"Warning: Illegal instruction detected: \"", "<<", "Err", "<<", "\"\\n\"", ";", "MI", "->", "dump", "(", ")", ";", "}", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ";", "++", "I", ";", "while", "(", "I", "!=", "MBB", "->", "end", "(", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "EmitInstruction", "(", "I", ")", ";", "++", "I", ";", "}", "}", "else", "{", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "if", "(", "DisasmEnabled", ")", "{", "DisasmLines", ".", "resize", "(", "DisasmLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "DisasmLine", "=", "DisasmLines", ".", "back", "(", ")", ";", "raw_string_ostream", "DisasmStream", "(", "DisasmLine", ")", ";", "AMDGPUInstPrinter", "InstPrinter", "(", "*", "TM", ".", "getMCAsmInfo", "(", ")", ",", "*", "TM", ".", "getInstrInfo", "(", ")", ",", "*", "TM", ".", "getRegisterInfo", "(", ")", ")", ";", "InstPrinter", ".", "printInst", "(", "&", "TmpInst", ",", "DisasmStream", ",", "StringRef", "(", ")", ")", ";", "SmallVector", "<", "MCFixup", ",", "4", ">", "Fixups", ";", "SmallVector", "<", "char", ",", "16", ">", "CodeBytes", ";", "raw_svector_ostream", "CodeStream", "(", "CodeBytes", ")", ";", "MCObjectStreamer", "&", "ObjStreamer", "=", "(", "MCObjectStreamer", "&", ")", "OutStreamer", ";", "MCCodeEmitter", "&", "InstEmitter", "=", "ObjStreamer", ".", "getAssembler", "(", ")", ".", "getEmitter", "(", ")", ";", "InstEmitter", ".", "EncodeInstruction", "(", "TmpInst", ",", "CodeStream", ",", "Fixups", ",", "TM", ".", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ")", ";", "CodeStream", ".", "flush", "(", ")", ";", "HexLines", ".", "resize", "(", "HexLines", ".", "size", "(", ")", "+", "1", ")", ";", "std", "::", "string", "&", "HexLine", "=", "HexLines", ".", "back", "(", ")", ";", "raw_string_ostream", "HexStream", "(", "HexLine", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CodeBytes", ".", "size", "(", ")", ";", "i", "+=", "4", ")", "{", "unsigned", "int", "CodeDWord", "=", "*", "(", "unsigned", "int", "*", ")", "&", "CodeBytes", "[", "i", "]", ";", "HexStream", "<<", "format", "(", "\"%s%08X\"", ",", "(", "i", ">", "0", "?", "\" \"", ":", "\"\"", ")", ",", "CodeDWord", ")", ";", "}", "DisasmStream", ".", "flush", "(", ")", ";", "DisasmLineMaxLen", "=", "std", "::", "max", "(", "DisasmLineMaxLen", ",", "DisasmLine", ".", "size", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "R600", "\"Warning: Illegal instruction detected: \"", "\"\\n\"", "1", "4", "16", "1", "0", "4", "\"%s%08X\"", "0", "\" \"", "\"\"" ]

[]

[ "<s>", "unsigned", "MipsCodeEmitter", "::", "getMachineOpValue", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "&", "MO", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MipsRegisterInfo", "::", "getRegisterNumbering", "(", "MO", ".", "getReg", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "emitGlobalAddress", "(", "MO", ".", "getGlobal", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ",", "true", ")", ";", "else", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "emitExternalSymbolAddress", "(", "MO", ".", "getSymbolName", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isCPI", "(", ")", ")", "emitConstPoolAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isJTI", "(", ")", ")", "emitJumpTableAddress", "(", "MO", ".", "getIndex", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "if", "(", "MO", ".", "isMBB", "(", ")", ")", "emitMachineBasicBlock", "(", "MO", ".", "getMBB", "(", ")", ",", "getRelocation", "(", "MI", ",", "MO", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Unable to encode MachineOperand!\"", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "\"Unable to encode MachineOperand!\"", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "MipsCC", "MipsCCInfo", "(", "CallConv", ",", "Subtarget", ".", "isABI_O32", "(", ")", ",", "Subtarget", ".", "isFP64bit", "(", ")", ",", "CCInfo", ")", ";", "MipsCCInfo", ".", "analyzeReturn", "(", "Outs", ",", "Subtarget", ".", "abiUsesSoftFloat", "(", ")", ",", "MF", ".", "getFunction", "(", ")", "->", "getReturnType", "(", ")", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Val", "=", "OutVals", "[", "i", "]", ";", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "if", "(", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", "!=", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ")", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "Val", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "MipsFI", "->", "getSRetReturnReg", "(", ")", ";", "if", "(", "!", "Reg", ")", "llvm_unreachable", "(", "\"sret virtual register not created in the entry block\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "unsigned", "V0", "=", "Subtarget", ".", "isABI_N64", "(", ")", "?", "Mips", "::", "V0_64", ":", "Mips", "::", "V0", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "V0", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "V0", ",", "getPointerTy", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "MipsISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::OutputArg", "16", "Mips", "Mips", "Mips", "4", "1", "0", "\"Can only return in registers!\"", "ISD::BITCAST", "1", "Mips", "Mips", "Mips", "Mips", "\"sret virtual register not created in the entry block\"", "Mips::V0_64", "Mips::V0", "1", "0", "MipsISD::Ret", "MVT::Other" ]

[]

[ "<s>", "StringRef", "AArch64NamedImmMapper", "::", "toString", "(", "uint32_t", "Value", ",", "uint64_t", "FeatureBits", ",", "bool", "&", "Valid", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "NumMappings", ";", "++", "i", ")", "{", "if", "(", "Mappings", "[", "i", "]", ".", "isValueEqual", "(", "Value", ",", "FeatureBits", ")", ")", "{", "Valid", "=", "true", ";", "return", "Mappings", "[", "i", "]", ".", "Name", ";", "}", "}", "Valid", "=", "false", ";", "return", "StringRef", "(", ")", ";", "}", "</s>" ]

[ "Convert", "to", "a", "decimal", "representation", "in", "a", "string", "." ]

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

[]

[ "<s>", "const", "unsigned", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "callsEHReturn", "=", "false", ";", "bool", "ghcCall", "=", "false", ";", "if", "(", "MF", ")", "{", "callsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "ghcCall", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ":", "false", ")", ";", "}", "if", "(", "ghcCall", ")", "return", "CSR_Ghc_SaveList", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "callsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "callsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86" ]

[]

[ "<s>", "const", "char", "*", "avr_out_insert_notbit", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "rtx", "xbitno", ",", "int", "*", "plen", ")", "{", "rtx", "op", "[", "4", "]", "=", "{", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ",", "xbitno", "==", "NULL_RTX", "?", "operands", "[", "3", "]", ":", "xbitno", "}", ";", "if", "(", "INTVAL", "(", "op", "[", "1", "]", ")", "==", "7", "&&", "test_hard_reg_class", "(", "LD_REGS", ",", "op", "[", "0", "]", ")", ")", "{", "if", "(", "INTVAL", "(", "op", "[", "3", "]", ")", "==", "7", "&&", "REGNO", "(", "op", "[", "0", "]", ")", "==", "REGNO", "(", "op", "[", "2", "]", ")", ")", "{", "avr_asm_len", "(", "\"subi %0,0x80\"", ",", "op", ",", "plen", ",", "-", "1", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"bst %2,%3\"", "CR_TAB", "\"bld %0,%1\"", "CR_TAB", "\"subi %0,0x80\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "}", "else", "if", "(", "test_hard_reg_class", "(", "LD_REGS", ",", "op", "[", "0", "]", ")", "&&", "(", "INTVAL", "(", "op", "[", "1", "]", ")", "!=", "INTVAL", "(", "op", "[", "3", "]", ")", "||", "!", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "op", "[", "2", "]", ")", ")", ")", "{", "avr_asm_len", "(", "\"andi %0,~(1<<%1)\"", "CR_TAB", "\"sbrs %2,%3\"", "CR_TAB", "\"ori %0,1<<%1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "{", "avr_asm_len", "(", "\"com %2\"", "CR_TAB", "\"bst %2,%3\"", ",", "op", ",", "plen", ",", "-", "2", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "op", "[", "2", "]", ")", "||", "reg_overlap_mentioned_p", "(", "op", "[", "0", "]", ",", "op", "[", "2", "]", ")", ")", "{", "avr_asm_len", "(", "\"com %2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "avr_asm_len", "(", "\"bld %0,%1\"", ",", "op", ",", "plen", ",", "1", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "instructions", "to", "insert", "an", "inverted", "bit", "into", "OPERANDS", "[", "0", "]", ":", "$", "0.", "$", "1", "=", "~", "$", "2.", "$", "3", "if", "XBITNO", "=", "NULL", "$", "0.", "$", "1", "=", "~", "$", "2.XBITNO", "if", "XBITNO", "!", "=", "NULL", ".", "If", "PLEN", "=", "NULL", "then", "output", "the", "respective", "instruction", "sequence", "which", "is", "a", "combination", "of", "BST", "/", "BLD", "and", "some", "instruction", "(", "s", ")", "to", "invert", "the", "bit", ".", "If", "PLEN", "!", "=", "NULL", "then", "store", "the", "length", "of", "the", "sequence", "(", "in", "words", ")", "in", "*", "PLEN", ".", "Return", "``", "''", "." ]

[ "avr", "4", "0", "1", "2", "3", "1", "7", "0", "3", "7", "0", "2", "\"subi %0,0x80\"", "1", "\"bst %2,%3\"", "\"bld %0,%1\"", "\"subi %0,0x80\"", "3", "0", "1", "3", "0", "2", "\"andi %0,~(1<<%1)\"", "\"sbrs %2,%3\"", "\"ori %0,1<<%1\"", "3", "\"com %2\"", "\"bst %2,%3\"", "2", "2", "0", "2", "\"com %2\"", "1", "\"bld %0,%1\"", "1", "\"\"" ]

[]

[ "<s>", "SDValue", "LC3bTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "std", "::", "cout", "<<", "\"Here it broke!!!!!\\n\"", ";", "return", "Chain", ";", "}", "</s>" ]

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

[ "LC3b", "LC3b", "ISD::OutputArg", "\"Here it broke!!!!!\\n\"" ]

[]

[ "<s>", "static", "void", "rs6000_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_conditional_register_usage called\\n\"", ")", ";", "fixed_regs", "[", "64", "]", "=", "1", ";", "if", "(", "TARGET_64BIT", ")", "fixed_regs", "[", "13", "]", "=", "call_used_regs", "[", "13", "]", "=", "call_really_used_regs", "[", "13", "]", "=", "1", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "for", "(", "i", "=", "32", ";", "i", "<", "64", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "call_really_used_regs", "[", "2", "]", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "2", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "1", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "!", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "VRSAVE_REGNO", "]", "=", "1", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "global_regs", "[", "VSCR_REGNO", "]", "=", "1", ";", "if", "(", "TARGET_ALTIVEC_ABI", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "++", "i", ")", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "TARGET_XCOFF", ")", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "32", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Change", "register", "usage", "conditional", "on", "target", "flags", "." ]

[ "rs6000", "\"rs6000_conditional_register_usage called\\n\"", "64", "1", "13", "13", "13", "1", "32", "64", "1", "2", "0", "2", "1", "1", "1", "1", "1", "1", "1", "1", "20", "1", "20", "32", "1" ]

[]

[ "<s>", "static", "void", "bpf_output_destructor", "(", "rtx", "symbol", ",", "int", "priority", "ATTRIBUTE_UNUSED", ")", "{", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "symbol", ")", ";", "if", "(", "decl", ")", "sorry_at", "(", "DECL_SOURCE_LOCATION", "(", "decl", ")", ",", "\"no destructors\"", ")", ";", "else", "sorry", "(", "\"no destructors\"", ")", ";", "}", "</s>" ]

[ "Output", "the", "assembly", "code", "for", "a", "destructor", ".", "Since", "eBPF", "does", "n't", "support", "indirect", "calls", ",", "destructors", "are", "not", "supported", "." ]

[ "bpf", "\"no destructors\"", "\"no destructors\"" ]

[]

[ "<s>", "static", "void", "aarch64_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gr_saved", ",", "vr_saved", ";", "local_cum", "=", "*", "cum", ";", "aarch64_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "mode", ",", "type", ",", "true", ")", ";", "gr_saved", "=", "NUM_ARG_REGS", "-", "local_cum", ".", "aapcs_ncrn", ";", "vr_saved", "=", "NUM_FP_ARG_REGS", "-", "local_cum", ".", "aapcs_nvrn", ";", "if", "(", "!", "TARGET_FLOAT", ")", "{", "gcc_assert", "(", "local_cum", ".", "aapcs_nvrn", "==", "0", ")", ";", "vr_saved", "=", "0", ";", "}", "if", "(", "!", "no_rtl", ")", "{", "if", "(", "gr_saved", ">", "0", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "-", "gr_saved", "*", "UNITS_PER_WORD", ")", ";", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "aapcs_ncrn", "+", "R0_REGNUM", ",", "mem", ",", "gr_saved", ")", ";", "}", "if", "(", "vr_saved", ">", "0", ")", "{", "machine_mode", "mode", "=", "TImode", ";", "int", "off", ",", "i", ";", "off", "=", "-", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "off", "-=", "vr_saved", "*", "UNITS_PER_VREG", ";", "for", "(", "i", "=", "local_cum", ".", "aapcs_nvrn", ";", "i", "<", "NUM_FP_ARG_REGS", ";", "++", "i", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "off", ")", ";", "mem", "=", "gen_frame_mem", "(", "mode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "aarch64_emit_move", "(", "mem", ",", "gen_rtx_REG", "(", "mode", ",", "V0_REGNUM", "+", "i", ")", ")", ";", "off", "+=", "UNITS_PER_VREG", ";", "}", "}", "}", "cfun", "->", "machine", "->", "frame", ".", "saved_varargs_size", "=", "(", "ROUND_UP", "(", "gr_saved", "*", "UNITS_PER_WORD", ",", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ")", "+", "vr_saved", "*", "UNITS_PER_VREG", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

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

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

[ "WebAssembly", "\"WebAssembly CallIndirect Fixup\"" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getString", "(", ")", ";", "if", "(", "IDVal", "==", "\".ent\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".end\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".frame\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".set\"", ")", "{", "return", "parseDirectiveSet", "(", ")", ";", "}", "if", "(", "IDVal", "==", "\".fmask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".mask\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".gpword\"", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "if", "(", "IDVal", "==", "\".word\"", ")", "{", "parseDirectiveWord", "(", "4", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\".ent\"", "\".end\"", "\".frame\"", "\".set\"", "\".fmask\"", "\".mask\"", "\".gpword\"", "\".word\"", "4" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseAsPrologue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "return", "!", "RegInfo", "->", "needsStackRealignment", "(", "*", "MF", ")", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "prologue", "for", "the", "target", "." ]

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

[]

[ "<s>", "void", "VERegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "VEFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Register", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "2", ")", ".", "getImm", "(", ")", ";", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "0", "\"Unexpected\"", "VE", "2" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_xcoff_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "align", ";", "unsigned", "int", "flags", "=", "default_section_type_flags_1", "(", "decl", ",", "name", ",", "reloc", ",", "1", ")", ";", "if", "(", "flags", "&", "SECTION_CODE", ")", "align", "=", "MIN_UNITS_PER_WORD", ";", "else", "align", "=", "MAX", "(", "(", "DECL_ALIGN", "(", "decl", ")", "/", "BITS_PER_UNIT", ")", ",", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ">", "MIN_UNITS_PER_WORD", "?", "UNITS_PER_FP_WORD", ":", "MIN_UNITS_PER_WORD", ")", ";", "return", "flags", "|", "(", "exact_log2", "(", "align", ")", "&", "SECTION_ENTSIZE", ")", ";", "}", "</s>" ]

[ "Section", "attributes", ".", "AIX", "is", "always", "PIC", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "bool", "aarch64_process_target_attr", "(", "tree", "args", ")", "{", "if", "(", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", ")", "{", "do", "{", "tree", "head", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "head", ")", "{", "if", "(", "!", "aarch64_process_target_attr", "(", "head", ")", ")", "return", "false", ";", "}", "args", "=", "TREE_CHAIN", "(", "args", ")", ";", "}", "while", "(", "args", ")", ";", "return", "true", ";", "}", "if", "(", "TREE_CODE", "(", "args", ")", "!=", "STRING_CST", ")", "{", "error", "(", "\"attribute %<target%> argument not a string\"", ")", ";", "return", "false", ";", "}", "size_t", "len", "=", "strlen", "(", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "char", "*", "str_to_check", "=", "(", "char", "*", ")", "alloca", "(", "len", "+", "1", ")", ";", "strcpy", "(", "str_to_check", ",", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "if", "(", "len", "==", "0", ")", "{", "error", "(", "\"malformed %<target()%> pragma or attribute\"", ")", ";", "return", "false", ";", "}", "unsigned", "int", "num_commas", "=", "num_occurences_in_str", "(", "','", ",", "str_to_check", ")", ";", "char", "*", "token", "=", "strtok_r", "(", "str_to_check", ",", "\",\"", ",", "&", "str_to_check", ")", ";", "unsigned", "int", "num_attrs", "=", "0", ";", "while", "(", "token", ")", "{", "num_attrs", "++", ";", "if", "(", "!", "aarch64_process_one_target_attr", "(", "token", ")", ")", "{", "error", "(", "\"pragma or attribute %<target(\\\"%s\\\")%> is not valid\"", ",", "token", ")", ";", "return", "false", ";", "}", "token", "=", "strtok_r", "(", "NULL", ",", "\",\"", ",", "&", "str_to_check", ")", ";", "}", "if", "(", "num_attrs", "!=", "num_commas", "+", "1", ")", "{", "error", "(", "\"malformed %<target(\\\"%s\\\")%> pragma or attribute\"", ",", "TREE_STRING_POINTER", "(", "args", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Parse", "the", "tree", "in", "ARGS", "that", "contains", "the", "target", "attribute", "information", "and", "update", "the", "global", "target", "options", "space", ".", "PRAGMA_OR_ATTR", "is", "a", "string", "to", "be", "used", "in", "error", "messages", ",", "specifying", "whether", "this", "is", "processing", "a", "target", "attribute", "or", "a", "target", "pragma", "." ]

[ "aarch64", "\"attribute %<target%> argument not a string\"", "1", "0", "\"malformed %<target()%> pragma or attribute\"", "\",\"", "0", "\"pragma or attribute %<target(\\\"%s\\\")%> is not valid\"", "\",\"", "1", "\"malformed %<target(\\\"%s\\\")%> pragma or attribute\"" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "RISCVISD", "::", "NODE", ":", "\\", "return", "\"RISCVISD::\"", "#", "NODE", ";", "switch", "(", "(", "RISCVISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "RISCVISD", "::", "FIRST_NUMBER", ":", "break", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", "NODE_NAME_CASE", "(", "URET_FLAG", ")", "NODE_NAME_CASE", "(", "SRET_FLAG", ")", "NODE_NAME_CASE", "(", "MRET_FLAG", ")", "NODE_NAME_CASE", "(", "CALL", ")", "NODE_NAME_CASE", "(", "SELECT_CC", ")", "NODE_NAME_CASE", "(", "BuildPairF64", ")", "NODE_NAME_CASE", "(", "SplitF64", ")", "NODE_NAME_CASE", "(", "TAIL", ")", "NODE_NAME_CASE", "(", "SLLW", ")", "NODE_NAME_CASE", "(", "SRAW", ")", "NODE_NAME_CASE", "(", "SRLW", ")", "NODE_NAME_CASE", "(", "DIVW", ")", "NODE_NAME_CASE", "(", "DIVUW", ")", "NODE_NAME_CASE", "(", "REMUW", ")", "NODE_NAME_CASE", "(", "ROLW", ")", "NODE_NAME_CASE", "(", "RORW", ")", "NODE_NAME_CASE", "(", "FSLW", ")", "NODE_NAME_CASE", "(", "FSRW", ")", "NODE_NAME_CASE", "(", "FMV_H_X", ")", "NODE_NAME_CASE", "(", "FMV_X_ANYEXTH", ")", "NODE_NAME_CASE", "(", "FMV_W_X_RV64", ")", "NODE_NAME_CASE", "(", "FMV_X_ANYEXTW_RV64", ")", "NODE_NAME_CASE", "(", "READ_CYCLE_WIDE", ")", "NODE_NAME_CASE", "(", "GREVI", ")", "NODE_NAME_CASE", "(", "GREVIW", ")", "NODE_NAME_CASE", "(", "GORCI", ")", "NODE_NAME_CASE", "(", "GORCIW", ")", "NODE_NAME_CASE", "(", "VMV_X_S", ")", "NODE_NAME_CASE", "(", "SPLAT_VECTOR_I64", ")", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCVISD::NODE", "\"RISCVISD::\"", "RISCVISD::NodeType", "RISCVISD::FIRST_NUMBER" ]

[]

[ "<s>", "const", "ARCTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "ARC", "ARC" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "size_t", "HexagonAbsoluteStub", "::", "size", "(", ")", "const", "{", "return", "m_Size", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "rs6000_cost_data", "::", "update_target_cost_per_stmt", "(", "vect_cost_for_stmt", "kind", ",", "stmt_vec_info", "stmt_info", ",", "vect_cost_model_location", "where", ",", "unsigned", "int", "orig_count", ")", "{", "if", "(", "kind", "==", "vec_to_scalar", "||", "kind", "==", "vec_perm", "||", "kind", "==", "vec_promote_demote", "||", "kind", "==", "vec_construct", "||", "kind", "==", "scalar_to_vec", "||", "(", "where", "==", "vect_body", "&&", "kind", "==", "vector_stmt", ")", ")", "m_vect_nonmem", "=", "true", ";", "if", "(", "!", "m_costing_for_scalar", "&&", "is_a", "<", "loop_vec_info", ">", "(", "m_vinfo", ")", "&&", "where", "==", "vect_body", ")", "{", "m_nstmts", "+=", "orig_count", ";", "if", "(", "kind", "==", "scalar_load", "||", "kind", "==", "vector_load", "||", "kind", "==", "unaligned_load", "||", "kind", "==", "vector_gather_load", ")", "m_nloads", "+=", "orig_count", ";", "if", "(", "kind", "==", "vec_construct", "&&", "stmt_info", "&&", "STMT_VINFO_TYPE", "(", "stmt_info", ")", "==", "load_vec_info_type", "&&", "(", "STMT_VINFO_MEMORY_ACCESS_TYPE", "(", "stmt_info", ")", "==", "VMAT_ELEMENTWISE", "||", "STMT_VINFO_MEMORY_ACCESS_TYPE", "(", "stmt_info", ")", "==", "VMAT_STRIDED_SLP", ")", ")", "{", "tree", "vectype", "=", "STMT_VINFO_VECTYPE", "(", "stmt_info", ")", ";", "unsigned", "int", "nunits", "=", "vect_nunits_for_cost", "(", "vectype", ")", ";", "if", "(", "nunits", "==", "1", ")", "return", ";", "unsigned", "int", "adjusted_cost", "=", "(", "nunits", "==", "2", ")", "?", "2", ":", "1", ";", "unsigned", "int", "extra_cost", "=", "nunits", "*", "adjusted_cost", ";", "m_extra_ctor_cost", "+=", "extra_cost", ";", "}", "}", "}", "</s>" ]

[ "Helper", "function", "for", "add_stmt_cost", ".", "Check", "each", "statement", "cost", "entry", ",", "gather", "information", "and", "update", "the", "target_cost", "fields", "accordingly", "." ]

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

[]

[ "<s>", "BTFTypeFuncProto", "::", "BTFTypeFuncProto", "(", "const", "DISubroutineType", "*", "STy", ",", "uint32_t", "VLen", ",", "const", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "&", "FuncArgNames", ")", ":", "STy", "(", "STy", ")", ",", "FuncArgNames", "(", "FuncArgNames", ")", "{", "Kind", "=", "BTF", "::", "BTF_KIND_FUNC_PROTO", ";", "BTFType", ".", "Info", "=", "(", "Kind", "<<", "24", ")", "|", "VLen", ";", "}", "</s>" ]

[ "The", "Func", "kind", "represents", "both", "subprogram", "and", "pointee", "of", "function", "pointers", "." ]

[ "BPF", "BTF::BTF_KIND_FUNC_PROTO", "24" ]

[]

[ "<s>", "static", "void", "expand_block_set_1", "(", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "byt_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "bytes_rtx", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "at", "address", "DST_REG", "to", "VALUE_RTX", "in", "1-byte", "chunks", "." ]

[ "visium", "1" ]

[]

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

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

[ "P2" ]

[]

[ "<s>", "void", "arc_eh_return_address_location", "(", "rtx", "source", ")", "{", "rtx", "mem", ";", "int", "offset", ";", "struct", "arc_frame_info", "*", "afi", ";", "arc_compute_frame_size", "(", ")", ";", "afi", "=", "&", "cfun", "->", "machine", "->", "frame_info", ";", "gcc_assert", "(", "crtl", "->", "calls_eh_return", ")", ";", "gcc_assert", "(", "afi", "->", "save_return_addr", ")", ";", "gcc_assert", "(", "afi", "->", "extra_size", ">=", "4", ")", ";", "offset", "=", "afi", "->", "reg_size", "+", "afi", "->", "extra_size", "-", "4", ";", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "offset", ")", ")", ";", "MEM_VOLATILE_P", "(", "mem", ")", "=", "true", ";", "emit_move_insn", "(", "mem", ",", "source", ")", ";", "}", "</s>" ]

[ "Return", "rtx", "for", "the", "location", "of", "the", "return", "address", "on", "the", "stack", ",", "suitable", "for", "use", "in", "__builtin_eh_return", ".", "The", "new", "return", "address", "will", "be", "written", "to", "this", "location", "in", "order", "to", "redirect", "the", "return", "to", "the", "exception", "handler", "." ]

[ "arc", "4", "4" ]

[]

[ "<s>", "int", "m32r_not_same_reg", "(", "rtx", "a", ",", "rtx", "b", ")", "{", "int", "reg_a", "=", "-", "1", ";", "int", "reg_b", "=", "-", "2", ";", "while", "(", "GET_CODE", "(", "a", ")", "==", "SUBREG", ")", "a", "=", "SUBREG_REG", "(", "a", ")", ";", "if", "(", "GET_CODE", "(", "a", ")", "==", "REG", ")", "reg_a", "=", "REGNO", "(", "a", ")", ";", "while", "(", "GET_CODE", "(", "b", ")", "==", "SUBREG", ")", "b", "=", "SUBREG_REG", "(", "b", ")", ";", "if", "(", "GET_CODE", "(", "b", ")", "==", "REG", ")", "reg_b", "=", "REGNO", "(", "b", ")", ";", "return", "reg_a", "!=", "reg_b", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "registers", "contained", "in", "the", "two", "rtl", "expressions", "are", "different", "." ]

[ "m32r", "1", "2" ]

[]

[ "<s>", "TargetTransformInfo", "DirectXTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "const", "{", "return", "TargetTransformInfo", "(", "DirectXTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "DirectX" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "isZExtFree", "(", "SDValue", "Val", ",", "EVT", "VT2", ")", "const", "{", "return", "isZExtFree", "(", "Val", ".", "getValueType", "(", ")", ",", "VT2", ")", ";", "}", "</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", ")", "." ]

[ "R600" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "ADD_F128", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "SUB_F128", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "MUL_F128", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128ToCall", "(", "Op", ",", "DAG", ",", "RTLIB", "::", "DIV_F128", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_INT", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "true", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerINT_TO_FP", "(", "Op", ",", "DAG", ",", "false", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "LowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_EXTEND", ":", "return", "LowerFP_EXTEND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL_PARTS", ":", "return", "LowerShiftLeftParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRL_PARTS", ":", "case", "ISD", "::", "SRA_PARTS", ":", "return", "LowerShiftRightParts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddressELF", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VACOPY", ":", "return", "LowerVACOPY", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ",", "getSubtarget", "(", ")", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom lower this!\"", "ISD::FADD", "ISD::FSUB", "ISD::FMUL", "ISD::FDIV", "ISD::FP_TO_SINT", "ISD::FP_TO_UINT", "ISD::SINT_TO_FP", "ISD::UINT_TO_FP", "ISD::FP_ROUND", "ISD::FP_EXTEND", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::SHL_PARTS", "ISD::SRL_PARTS", "ISD::SRA_PARTS", "ISD::BlockAddress", "ISD::BRCOND", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::ConstantPool", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::SELECT", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VACOPY", "ISD::VASTART", "ISD::BUILD_VECTOR", "ISD::CONCAT_VECTORS", "ISD::VECTOR_SHUFFLE" ]

[]

[ "<s>", "void", "XCoreInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "I", "->", "isDebugValue", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "XCore", "::", "STWFI", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::STWFI", "0" ]

[]