Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "AArch64ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "auto", "UniqueRS", "=", "make_unique", "<", "RegScavenger", ">", "(", ")", ";", "RS", "=", "UniqueRS", ".", "get", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "MipsTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "MipsISD", "::", "JmpLink", ":", "return", "\"MipsISD::JmpLink\"", ";", "case", "MipsISD", "::", "TailCall", ":", "return", "\"MipsISD::TailCall\"", ";", "case", "MipsISD", "::", "Hi", ":", "return", "\"MipsISD::Hi\"", ";", "case", "MipsISD", "::", "Lo", ":", "return", "\"MipsISD::Lo\"", ";", "case", "MipsISD", "::", "GPRel", ":", "return", "\"MipsISD::GPRel\"", ";", "case", "MipsISD", "::", "ThreadPointer", ":", "return", "\"MipsISD::ThreadPointer\"", ";", "case", "MipsISD", "::", "Ret", ":", "return", "\"MipsISD::Ret\"", ";", "case", "MipsISD", "::", "FPBrcond", ":", "return", "\"MipsISD::FPBrcond\"", ";", "case", "MipsISD", "::", "FPCmp", ":", "return", "\"MipsISD::FPCmp\"", ";", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "\"MipsISD::CMovFP_T\"", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "return", "\"MipsISD::CMovFP_F\"", ";", "case", "MipsISD", "::", "FPRound", ":", "return", "\"MipsISD::FPRound\"", ";", "case", "MipsISD", "::", "MAdd", ":", "return", "\"MipsISD::MAdd\"", ";", "case", "MipsISD", "::", "MAddu", ":", "return", "\"MipsISD::MAddu\"", ";", "case", "MipsISD", "::", "MSub", ":", "return", "\"MipsISD::MSub\"", ";", "case", "MipsISD", "::", "MSubu", ":", "return", "\"MipsISD::MSubu\"", ";", "case", "MipsISD", "::", "DivRem", ":", "return", "\"MipsISD::DivRem\"", ";", "case", "MipsISD", "::", "DivRemU", ":", "return", "\"MipsISD::DivRemU\"", ";", "case", "MipsISD", "::", "BuildPairF64", ":", "return", "\"MipsISD::BuildPairF64\"", ";", "case", "MipsISD", "::", "ExtractElementF64", ":", "return", "\"MipsISD::ExtractElementF64\"", ";", "case", "MipsISD", "::", "Wrapper", ":", "return", "\"MipsISD::Wrapper\"", ";", "case", "MipsISD", "::", "Sync", ":", "return", "\"MipsISD::Sync\"", ";", "case", "MipsISD", "::", "Ext", ":", "return", "\"MipsISD::Ext\"", ";", "case", "MipsISD", "::", "Ins", ":", "return", "\"MipsISD::Ins\"", ";", "case", "MipsISD", "::", "LWL", ":", "return", "\"MipsISD::LWL\"", ";", "case", "MipsISD", "::", "LWR", ":", "return", "\"MipsISD::LWR\"", ";", "case", "MipsISD", "::", "SWL", ":", "return", "\"MipsISD::SWL\"", ";", "case", "MipsISD", "::", "SWR", ":", "return", "\"MipsISD::SWR\"", ";", "case", "MipsISD", "::", "LDL", ":", "return", "\"MipsISD::LDL\"", ";", "case", "MipsISD", "::", "LDR", ":", "return", "\"MipsISD::LDR\"", ";", "case", "MipsISD", "::", "SDL", ":", "return", "\"MipsISD::SDL\"", ";", "case", "MipsISD", "::", "SDR", ":", "return", "\"MipsISD::SDR\"", ";", "case", "MipsISD", "::", "EXTP", ":", "return", "\"MipsISD::EXTP\"", ";", "case", "MipsISD", "::", "EXTPDP", ":", "return", "\"MipsISD::EXTPDP\"", ";", "case", "MipsISD", "::", "EXTR_S_H", ":", "return", "\"MipsISD::EXTR_S_H\"", ";", "case", "MipsISD", "::", "EXTR_W", ":", "return", "\"MipsISD::EXTR_W\"", ";", "case", "MipsISD", "::", "EXTR_R_W", ":", "return", "\"MipsISD::EXTR_R_W\"", ";", "case", "MipsISD", "::", "EXTR_RS_W", ":", "return", "\"MipsISD::EXTR_RS_W\"", ";", "case", "MipsISD", "::", "SHILO", ":", "return", "\"MipsISD::SHILO\"", ";", "case", "MipsISD", "::", "MTHLIP", ":", "return", "\"MipsISD::MTHLIP\"", ";", "case", "MipsISD", "::", "MULT", ":", "return", "\"MipsISD::MULT\"", ";", "case", "MipsISD", "::", "MULTU", ":", "return", "\"MipsISD::MULTU\"", ";", "case", "MipsISD", "::", "MADD_DSP", ":", "return", "\"MipsISD::MADD_DSPDSP\"", ";", "case", "MipsISD", "::", "MADDU_DSP", ":", "return", "\"MipsISD::MADDU_DSP\"", ";", "case", "MipsISD", "::", "MSUB_DSP", ":", "return", "\"MipsISD::MSUB_DSP\"", ";", "case", "MipsISD", "::", "MSUBU_DSP", ":", "return", "\"MipsISD::MSUBU_DSP\"", ";", "default", ":", "return", "NULL", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "MipsISD::JmpLink", "\"MipsISD::JmpLink\"", "MipsISD::TailCall", "\"MipsISD::TailCall\"", "MipsISD::Hi", "\"MipsISD::Hi\"", "MipsISD::Lo", "\"MipsISD::Lo\"", "MipsISD::GPRel", "\"MipsISD::GPRel\"", "MipsISD::ThreadPointer", "\"MipsISD::ThreadPointer\"", "MipsISD::Ret", "\"MipsISD::Ret\"", "MipsISD::FPBrcond", "\"MipsISD::FPBrcond\"", "MipsISD::FPCmp", "\"MipsISD::FPCmp\"", "MipsISD::CMovFP_T", "\"MipsISD::CMovFP_T\"", "MipsISD::CMovFP_F", "\"MipsISD::CMovFP_F\"", "MipsISD::FPRound", "\"MipsISD::FPRound\"", "MipsISD::MAdd", "\"MipsISD::MAdd\"", "MipsISD::MAddu", "\"MipsISD::MAddu\"", "MipsISD::MSub", "\"MipsISD::MSub\"", "MipsISD::MSubu", "\"MipsISD::MSubu\"", "MipsISD::DivRem", "\"MipsISD::DivRem\"", "MipsISD::DivRemU", "\"MipsISD::DivRemU\"", "MipsISD::BuildPairF64", "\"MipsISD::BuildPairF64\"", "MipsISD::ExtractElementF64", "\"MipsISD::ExtractElementF64\"", "MipsISD::Wrapper", "\"MipsISD::Wrapper\"", "MipsISD::Sync", "\"MipsISD::Sync\"", "MipsISD::Ext", "\"MipsISD::Ext\"", "MipsISD::Ins", "\"MipsISD::Ins\"", "MipsISD::LWL", "\"MipsISD::LWL\"", "MipsISD::LWR", "\"MipsISD::LWR\"", "MipsISD::SWL", "\"MipsISD::SWL\"", "MipsISD::SWR", "\"MipsISD::SWR\"", "MipsISD::LDL", "\"MipsISD::LDL\"", "MipsISD::LDR", "\"MipsISD::LDR\"", "MipsISD::SDL", "\"MipsISD::SDL\"", "MipsISD::SDR", "\"MipsISD::SDR\"", "MipsISD::EXTP", "\"MipsISD::EXTP\"", "MipsISD::EXTPDP", "\"MipsISD::EXTPDP\"", "MipsISD::EXTR_S_H", "\"MipsISD::EXTR_S_H\"", "MipsISD::EXTR_W", "\"MipsISD::EXTR_W\"", "MipsISD::EXTR_R_W", "\"MipsISD::EXTR_R_W\"", "MipsISD::EXTR_RS_W", "\"MipsISD::EXTR_RS_W\"", "MipsISD::SHILO", "\"MipsISD::SHILO\"", "MipsISD::MTHLIP", "\"MipsISD::MTHLIP\"", "MipsISD::MULT", "\"MipsISD::MULT\"", "MipsISD::MULTU", "\"MipsISD::MULTU\"", "MipsISD::MADD_DSP", "\"MipsISD::MADD_DSPDSP\"", "MipsISD::MADDU_DSP", "\"MipsISD::MADDU_DSP\"", "MipsISD::MSUB_DSP", "\"MipsISD::MSUB_DSP\"", "MipsISD::MSUBU_DSP", "\"MipsISD::MSUBU_DSP\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "getMemOperandsWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "SmallVectorImpl", "<", "const", "MachineOperand", "*", ">", "&", "BaseOps", ",", "int64_t", "&", "Offset", ",", "bool", "&", "OffsetIsScalable", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "OffsetIsScalable", "=", "false", ";", "const", "MachineOperand", "*", "BaseOp", "=", "getBaseAndOffset", "(", "LdSt", ",", "Offset", ",", "Width", ")", ";", "if", "(", "!", "BaseOp", "||", "!", "BaseOp", "->", "isReg", "(", ")", ")", "return", "false", ";", "BaseOps", ".", "push_back", "(", "BaseOp", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Get", "zero", "or", "more", "base", "operands", "and", "the", "byte", "offset", "of", "an", "instruction", "that", "reads/writes", "memory", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_build_lower", "(", "struct", "mips_integer_op", "*", "codes", ",", "unsigned", "HOST_WIDE_INT", "value", ")", "{", "unsigned", "HOST_WIDE_INT", "high", ";", "unsigned", "int", "i", ";", "high", "=", "value", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "0xffff", ";", "if", "(", "!", "LUI_OPERAND", "(", "high", ")", "&&", "(", "value", "&", "0x18000", ")", "==", "0x18000", ")", "{", "i", "=", "mips_build_integer", "(", "codes", ",", "CONST_HIGH_PART", "(", "value", ")", ")", ";", "codes", "[", "i", "]", ".", "code", "=", "PLUS", ";", "codes", "[", "i", "]", ".", "value", "=", "CONST_LOW_PART", "(", "value", ")", ";", "}", "else", "{", "i", "=", "mips_build_integer", "(", "codes", ",", "high", ")", ";", "codes", "[", "i", "]", ".", "code", "=", "IOR", ";", "codes", "[", "i", "]", ".", "value", "=", "value", "&", "0xffff", ";", "}", "return", "i", "+", "1", ";", "}", "</s>" ]

[ "As", "for", "mips_build_shift", ",", "but", "assume", "that", "the", "final", "action", "will", "be", "an", "IOR", "or", "PLUS", "operation", "." ]

[ "mips", "0xffff", "0x18000", "0x18000", "0xffff", "1" ]

[]

[ "<s>", "int", "SparcSubtarget", "::", "getAdjustedFrameSize", "(", "int", "frameSize", ")", "const", "{", "if", "(", "is64Bit", "(", ")", ")", "{", "frameSize", "+=", "128", ";", "frameSize", "=", "RoundUpToAlignment", "(", "frameSize", ",", "16", ")", ";", "}", "else", "{", "frameSize", "+=", "92", ";", "frameSize", "=", "RoundUpToAlignment", "(", "frameSize", ",", "8", ")", ";", "}", "return", "frameSize", ";", "}", "</s>" ]

[ "Given", "a", "actual", "stack", "size", "as", "determined", "by", "FrameInfo", ",", "this", "function", "returns", "adjusted", "framesize", "which", "includes", "space", "for", "RSA", ",", "return", "address", ",", "and", "frame", "poitner", "." ]

[ "Sparc", "Sparc", "128", "16", "92", "8" ]

[]

[ "<s>", "static", "bool", "rs6000_assemble_integer", "(", "rtx", "x", ",", "unsigned", "int", "size", ",", "int", "aligned_p", ")", "{", "if", "(", "RELOCATABLE_NEEDS_FIXUP", "&&", "size", "==", "4", "&&", "aligned_p", ")", "{", "extern", "int", "in_toc_section", "(", "void", ")", ";", "static", "int", "recurse", "=", "0", ";", "if", "(", "TARGET_RELOCATABLE", "&&", "!", "in_toc_section", "(", ")", "&&", "!", "in_text_section", "(", ")", "&&", "!", "in_unlikely_text_section", "(", ")", "&&", "!", "recurse", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_INT", "&&", "GET_CODE", "(", "x", ")", "!=", "CONST_DOUBLE", "&&", "CONSTANT_P", "(", "x", ")", ")", "{", "char", "buf", "[", "256", "]", ";", "recurse", "=", "1", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LCP\"", ",", "fixuplabelno", ")", ";", "fixuplabelno", "++", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "buf", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t(\"", ")", ";", "output_addr_const", "(", "asm_out_file", ",", "x", ")", ";", "fprintf", "(", "asm_out_file", ",", "\")@fixup\\n\"", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"", ")", ";", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "2", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t\"", ")", ";", "assemble_name", "(", "asm_out_file", ",", "buf", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\n\\t.previous\\n\"", ")", ";", "recurse", "=", "0", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "XSTR", "(", "x", ",", "0", ")", "[", "0", "]", "==", "'.'", "&&", "DEFAULT_ABI", "==", "ABI_AIX", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "x", ",", "0", ")", ";", "while", "(", "*", "name", "==", "'.'", ")", "name", "++", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.long\\t%s\\n\"", ",", "name", ")", ";", "return", "true", ";", "}", "}", "return", "default_assemble_integer", "(", "x", ",", "size", ",", "aligned_p", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "assembling", "integer", "objects", ".", "The", "powerpc", "version", "has", "to", "handle", "fixup", "entries", "for", "relocatable", "code", "if", "RELOCATABLE_NEEDS_FIXUP", "is", "defined", ".", "It", "also", "needs", "to", "handle", "DI-mode", "objects", "on", "64-bit", "targets", "." ]

[ "rs6000", "4", "0", "256", "1", "\"LCP\"", "\"\\t.long\\t(\"", "\")@fixup\\n\"", "\"\\t.section\\t\\\".fixup\\\",\\\"aw\\\"\\n\"", "2", "\"\\t.long\\t\"", "\"\\n\\t.previous\\n\"", "0", "0", "0", "0", "\"\\t.long\\t%s\\n\"" ]

[]

[ "<s>", "static", "void", "ix86_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "int", "nregs", ";", "if", "(", "!", "cum", "->", "caller", "&&", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "return", ";", "bytes", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "words", "=", "CEIL", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "arg", ".", "type", ")", "mode", "=", "type_natural_mode", "(", "arg", ".", "type", ",", "NULL", ",", "false", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "nregs", "=", "function_arg_advance_ms_64", "(", "cum", ",", "bytes", ",", "words", ")", ";", "else", "nregs", "=", "function_arg_advance_64", "(", "cum", ",", "mode", ",", "arg", ".", "type", ",", "words", ",", "arg", ".", "named", ")", ";", "}", "else", "nregs", "=", "function_arg_advance_32", "(", "cum", ",", "mode", ",", "arg", ".", "type", ",", "bytes", ",", "words", ")", ";", "if", "(", "!", "nregs", ")", "{", "if", "(", "cum", "->", "caller", ")", "cfun", "->", "machine", "->", "outgoing_args_on_stack", "=", "true", ";", "}", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "i386" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitFunctionBodyEnd", "(", ")", "{", "if", "(", "!", "AArch64FI", "->", "getLOHRelated", "(", ")", ".", "empty", "(", ")", ")", "EmitLOHs", "(", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "after", "the", "last", "basic", "block", "in", "the", "function", "." ]

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

[]

[ "<s>", "void", "output_ascii", "(", "FILE", "*", "file", ",", "const", "char", "*", "p", ",", "int", "size", ")", "{", "int", "i", ",", "c", ";", "const", "char", "*", "pseudo", "=", "\"\\t.ascii\\t\"", ";", "bool", "delim", "=", "false", ";", "if", "(", "TARGET_DEC_ASM", ")", "{", "if", "(", "p", "[", "size", "-", "1", "]", "==", "'\\0'", ")", "{", "pseudo", "=", "\"\\t.asciz\\t\"", ";", "size", "--", ";", "}", "fputs", "(", "pseudo", ",", "file", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "c", "=", "*", "p", "++", "&", "0xff", ";", "if", "(", "c", "<", "32", "||", "c", "==", "'\"'", "||", "c", ">", "126", ")", "{", "if", "(", "delim", ")", "putc", "(", "'\"'", ",", "file", ")", ";", "fprintf", "(", "file", ",", "\"<%o>\"", ",", "c", ")", ";", "delim", "=", "false", ";", "}", "else", "{", "if", "(", "!", "delim", ")", "putc", "(", "'\"'", ",", "file", ")", ";", "delim", "=", "true", ";", "putc", "(", "c", ",", "file", ")", ";", "}", "}", "if", "(", "delim", ")", "putc", "(", "'\"'", ",", "file", ")", ";", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "else", "{", "fprintf", "(", "file", ",", "\"\\t.byte \"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "fprintf", "(", "file", ",", "\"%#o\"", ",", "*", "p", "++", "&", "0xff", ")", ";", "if", "(", "i", "<", "size", "-", "1", ")", "putc", "(", "','", ",", "file", ")", ";", "}", "putc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "</s>" ]

[ "Output", "an", "assembler", "pseudo-op", "to", "write", "an", "ASCII", "string", "of", "N", "characters", "starting", "at", "P", "to", "FILE", ".", "On", "the", "RS/6000", ",", "we", "have", "to", "do", "this", "using", "the", ".byte", "operation", "and", "write", "out", "special", "characters", "outside", "the", "quoted", "string", ".", "Also", ",", "the", "assembler", "is", "broken", ";", "very", "long", "strings", "are", "truncated", ",", "so", "we", "must", "artificially", "break", "them", "up", "early", "." ]

[ "pdp11", "\"\\t.ascii\\t\"", "1", "\"\\t.asciz\\t\"", "0", "0xff", "32", "126", "\"<%o>\"", "\"\\t.byte \"", "0", "\"%#o\"", "0xff", "1" ]

[]

[ "<s>", "void", "Cpu0DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "if", "(", "trySelect", "(", "Node", ")", ")", "return", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "ReplaceNode", "(", "Node", ",", "getGlobalBaseReg", "(", ")", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "1", "ISD::GLOBAL_OFFSET_TABLE" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"2003f DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "F2003f", "\"2003f DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "void", "ELFAArch64AsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "!", "IsLittleEndian", "&&", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", ")", "{", "const", "MCSection", "*", "Sec", "=", "Fixup", ".", "getValue", "(", ")", "->", "FindAssociatedSection", "(", ")", ";", "const", "MCSectionELF", "*", "SecELF", "=", "static_cast", "<", "const", "MCSectionELF", "*", ">", "(", "Sec", ")", ";", "if", "(", "SecELF", "->", "getSectionName", "(", ")", "==", "\".eh_frame\"", ")", "Value", "=", "ByteSwap_32", "(", "unsigned", "(", "Value", ")", ")", ";", "}", "AArch64AsmBackend", "::", "applyFixup", "(", "Fixup", ",", "Data", ",", "DataSize", ",", "Value", ",", "IsPCRel", ")", ";", "}", "</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", "." ]

[ "AArch64", "AArch64", "\".eh_frame\"", "AArch64" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", "->", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getMMI", "(", ")", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "I", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "if", "(", "!", "(", "Fn", "->", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "I", ",", "DL", ",", "StackAdjustment", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "I", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "I", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "aarch64_svpattern", "aarch64_svpattern_for_vl", "(", "machine_mode", "pred_mode", ",", "int", "vl", ")", "{", "if", "(", "vl", "<", "0", ")", "return", "AARCH64_SV_ALL", ";", "if", "(", "maybe_gt", "(", "vl", ",", "GET_MODE_NUNITS", "(", "pred_mode", ")", ")", ")", "return", "AARCH64_NUM_SVPATTERNS", ";", "if", "(", "vl", ">=", "1", "&&", "vl", "<=", "8", ")", "return", "aarch64_svpattern", "(", "AARCH64_SV_VL1", "+", "(", "vl", "-", "1", ")", ")", ";", "if", "(", "vl", ">=", "16", "&&", "vl", "<=", "256", "&&", "pow2p_hwi", "(", "vl", ")", ")", "return", "aarch64_svpattern", "(", "AARCH64_SV_VL16", "+", "(", "exact_log2", "(", "vl", ")", "-", "4", ")", ")", ";", "int", "max_vl", ";", "if", "(", "GET_MODE_NUNITS", "(", "pred_mode", ")", ".", "is_constant", "(", "&", "max_vl", ")", ")", "{", "if", "(", "vl", "==", "(", "max_vl", "/", "3", ")", "*", "3", ")", "return", "AARCH64_SV_MUL3", ";", "if", "(", "vl", "==", "(", "max_vl", "&", "-", "4", ")", ")", "return", "AARCH64_SV_MUL4", ";", "if", "(", "vl", "==", "(", "1", "<<", "floor_log2", "(", "max_vl", ")", ")", ")", "return", "AARCH64_SV_POW2", ";", "if", "(", "vl", "==", "max_vl", ")", "return", "AARCH64_SV_ALL", ";", "}", "return", "AARCH64_NUM_SVPATTERNS", ";", "}", "</s>" ]

[ "See", "if", "there", "is", "an", "svpattern", "that", "encodes", "an", "SVE", "predicate", "of", "mode", "PRED_MODE", "in", "which", "the", "first", "VL", "bits", "are", "set", "and", "the", "rest", "are", "clear", ".", "Return", "the", "pattern", "if", "so", ",", "otherwise", "return", "AARCH64_NUM_SVPATTERNS", ".", "A", "VL", "of", "-1", "indicates", "an", "all-true", "vector", "." ]

[ "aarch64", "0", "1", "8", "1", "16", "256", "4", "3", "3", "4", "1" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "bool", "isPIC", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", ";", "adjustMipsStackFrame", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", ")", "return", ";", "int", "FPOffset", "=", "MipsFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MipsFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOREORDER", ")", ")", ";", "if", "(", "isPIC", "&&", "Subtarget", ".", "isABI_O32", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPLOAD", ")", ")", ".", "addReg", "(", "getPICCallReg", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "NOMACRO", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDiu", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "RA", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "SW", ")", ")", ".", "addReg", "(", "Mips", "::", "FP", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "ADDu", ")", ",", "Mips", "::", "FP", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ";", "}", "if", "(", "MipsFI", "->", "needGPSaveRestore", "(", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "CPRESTORE", ")", ")", ".", "addImm", "(", "MipsFI", "->", "getGPStackOffset", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips", "Mips", "Mips::NOREORDER", "Mips::CPLOAD", "Mips::NOMACRO", "Mips::ADDiu", "Mips::SP", "Mips::SP", "Mips::SW", "Mips::RA", "Mips::SP", "Mips::SW", "Mips::FP", "Mips::SP", "Mips::ADDu", "Mips::FP", "Mips::SP", "Mips::ZERO", "Mips", "Mips::CPRESTORE", "Mips" ]

[]

[ "<s>", "static", "bool", "alpha_pass_by_reference", "(", "cumulative_args_t", "ca", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", ")", "{", "if", "(", "mode", "==", "SFmode", "||", "mode", "==", "SCmode", ")", "return", "!", "named", ";", "return", "mode", "==", "TFmode", "||", "mode", "==", "TCmode", ";", "}", "</s>" ]

[ "Return", "true", "if", "TYPE", "should", "be", "passed", "by", "invisible", "reference", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "alpha_extra_constraint", "(", "rtx", "value", ",", "int", "c", ")", "{", "switch", "(", "c", ")", "{", "case", "'Q'", ":", "return", "normal_memory_operand", "(", "value", ",", "VOIDmode", ")", ";", "case", "'R'", ":", "return", "direct_call_operand", "(", "value", ",", "Pmode", ")", ";", "case", "'S'", ":", "return", "(", "GET_CODE", "(", "value", ")", "==", "CONST_INT", "&&", "(", "unsigned", "HOST_WIDE_INT", ")", "INTVAL", "(", "value", ")", "<", "64", ")", ";", "case", "'T'", ":", "return", "GET_CODE", "(", "value", ")", "==", "HIGH", ";", "case", "'U'", ":", "return", "TARGET_ABI_UNICOSMK", "&&", "symbolic_operand", "(", "value", ",", "VOIDmode", ")", ";", "case", "'W'", ":", "return", "(", "GET_CODE", "(", "value", ")", "==", "CONST_VECTOR", "&&", "value", "==", "CONST0_RTX", "(", "GET_MODE", "(", "value", ")", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implements", "CONST_DOUBLE_OK_FOR_LETTER_P", ".", "Return", "true", "if", "VALUE", "matches", "for", "C", "." ]

[ "alpha", "64" ]

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "::", "getUnknownLoc", "(", ")", ")", ";", "adjustMBlazeStackFrame", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "hasCalls", "(", ")", ")", "return", ";", "if", "(", "StackSize", "<", "28", "&&", "MFI", "->", "hasCalls", "(", ")", ")", "StackSize", "=", "28", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R15", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "}", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "28", "28", "MBlaze", "MBlaze", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R15", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::ADD", "MBlaze::R19", "MBlaze::R1", "MBlaze::R0" ]

[]

[ "<s>", "ArrayRef", "<", "const", "Metadata", "*", ">", "getNonMDStrings", "(", ")", "const", "{", "return", "makeArrayRef", "(", "MDs", ")", ".", "slice", "(", "NumModuleMDs", ")", ".", "slice", "(", "NumMDStrings", ")", ";", "}", "</s>" ]

[ "Get", "the", "non-MDString", "metadata", "for", "this", "block", "." ]

[ "DirectX" ]

[]

[ "<s>", "static", "bool", "insn_clobbers_hbr", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", ")", "{", "rtx", "parallel", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "clobber", ";", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "parallel", ",", "0", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "{", "clobber", "=", "XVECEXP", "(", "parallel", ",", "0", ",", "j", ")", ";", "if", "(", "GET_CODE", "(", "clobber", ")", "==", "CLOBBER", "&&", "GET_CODE", "(", "XEXP", "(", "clobber", ",", "0", ")", ")", "==", "REG", "&&", "REGNO", "(", "XEXP", "(", "clobber", ",", "0", ")", ")", "==", "HBR_REGNUM", ")", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "The", "special", "$", "hbr", "register", "is", "used", "to", "prevent", "the", "insn", "scheduler", "from", "moving", "hbr", "insns", "across", "instructions", "which", "invalidate", "them", ".", "It", "should", "only", "be", "used", "in", "a", "clobber", ",", "and", "this", "function", "searches", "for", "insns", "which", "clobber", "it", "." ]

[ "spu", "0", "1", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addPreRegAlloc", "(", ")", "{", "PM", "->", "add", "(", "createX86MaxStackAlignmentHeuristicPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "emitSPUpdate", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "unsigned", "StackPtr", ",", "int64_t", "NumBytes", ",", "bool", "Is64Bit", ",", "bool", "IsLP64", ",", "bool", "UseLEA", ",", "const", "TargetInstrInfo", "&", "TII", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "{", "bool", "isSub", "=", "NumBytes", "<", "0", ";", "uint64_t", "Offset", "=", "isSub", "?", "-", "NumBytes", ":", "NumBytes", ";", "unsigned", "Opc", ";", "if", "(", "UseLEA", ")", "Opc", "=", "getLEArOpcode", "(", "IsLP64", ")", ";", "else", "Opc", "=", "isSub", "?", "getSUBriOpcode", "(", "IsLP64", ",", "Offset", ")", ":", "getADDriOpcode", "(", "IsLP64", ",", "Offset", ")", ";", "uint64_t", "Chunk", "=", "(", "1LL", "<<", "31", ")", "-", "1", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "while", "(", "Offset", ")", "{", "uint64_t", "ThisVal", "=", "(", "Offset", ">", "Chunk", ")", "?", "Chunk", ":", "Offset", ";", "if", "(", "ThisVal", "==", "(", "Is64Bit", "?", "8", ":", "4", ")", ")", "{", "unsigned", "Reg", "=", "isSub", "?", "(", "unsigned", ")", "(", "Is64Bit", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ")", ":", "findDeadCallerSavedReg", "(", "MBB", ",", "MBBI", ",", "TRI", ",", "Is64Bit", ")", ";", "if", "(", "Reg", ")", "{", "Opc", "=", "isSub", "?", "(", "Is64Bit", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ")", ":", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getDefRegState", "(", "!", "isSub", ")", "|", "getUndefRegState", "(", "isSub", ")", ")", ";", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "continue", ";", "}", "}", "MachineInstr", "*", "MI", "=", "nullptr", ";", "if", "(", "UseLEA", ")", "{", "MI", "=", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ",", "StackPtr", ",", "false", ",", "isSub", "?", "-", "ThisVal", ":", "ThisVal", ")", ";", "}", "else", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "ThisVal", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "if", "(", "isSub", ")", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "Offset", "-=", "ThisVal", ";", "}", "}", "</s>" ]

[ "Emit", "a", "series", "of", "instructions", "to", "increment", "/", "decrement", "the", "stack", "pointer", "by", "a", "constant", "value", "." ]

[ "X86", "0", "1LL", "31", "1", "8", "4", "X86::RAX", "X86::EAX", "X86::PUSH64r", "X86::PUSH32r", "X86::POP64r", "X86::POP32r", "3" ]

[]

[ "<s>", "void", "SystemZFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "usePackedStack", "(", "MF", ")", ")", "getOrCreateFramePointerSaveIndex", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "(", "MFFrame", ".", "estimateStackSize", "(", "MF", ")", "+", "SystemZMC", "::", "CallFrameSize", ")", ";", "int64_t", "MaxArgOffset", "=", "0", ";", "for", "(", "int", "I", "=", "MFFrame", ".", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "if", "(", "MFFrame", ".", "getObjectOffset", "(", "I", ")", ">=", "0", ")", "{", "int64_t", "ArgOffset", "=", "MFFrame", ".", "getObjectOffset", "(", "I", ")", "+", "MFFrame", ".", "getObjectSize", "(", "I", ")", ";", "MaxArgOffset", "=", "std", "::", "max", "(", "MaxArgOffset", ",", "ArgOffset", ")", ";", "}", "uint64_t", "MaxReach", "=", "StackSize", "+", "MaxArgOffset", ";", "if", "(", "!", "isUInt", "<", "12", ">", "(", "MaxReach", ")", ")", "{", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "8", ",", "false", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "MFFrame", ".", "CreateStackObject", "(", "8", ",", "8", ",", "false", ")", ")", ";", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "SystemZMC::CallFrameSize", "0", "0", "0", "12", "8", "8", "8", "8" ]

[]

[ "<s>", "bool", "WebAssemblyAddMissingPrototypes", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"runnning AddMissingPrototypes\\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", "(", "BitCastOperator", "*", "BC", "=", "dyn_cast", "<", "BitCastOperator", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "FunctionType", "*", "DestType", "=", "cast", "<", "FunctionType", ">", "(", "BC", "->", "getDestTy", "(", ")", "->", "getPointerElementType", "(", ")", ")", ";", "NewType", "=", "DestType", ";", "NewF", "=", "Function", "::", "Create", "(", "NewType", ",", "F", ".", "getLinkage", "(", ")", ",", "F", ".", "getName", "(", ")", ")", ";", "NewF", "->", "setAttributes", "(", "F", ".", "getAttributes", "(", ")", ")", ";", "NewF", "->", "removeFnAttr", "(", "\"no-prototype\"", ")", ";", "break", ";", "}", "}", "if", "(", "!", "NewType", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"could not derive a function prototype from usage: \"", "+", "F", ".", "getName", "(", ")", "+", "\"\\n\"", ")", ";", "continue", ";", "}", "for", "(", "Use", "&", "U", ":", "F", ".", "uses", "(", ")", ")", "{", "if", "(", "BitCastOperator", "*", "BC", "=", "dyn_cast", "<", "BitCastOperator", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "FunctionType", "*", "DestType", "=", "cast", "<", "FunctionType", ">", "(", "BC", "->", "getDestTy", "(", ")", "->", "getPointerElementType", "(", ")", ")", ";", "if", "(", "NewType", "!=", "DestType", ")", "{", "report_fatal_error", "(", "\"Prototypeless function used with conflicting signatures: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "}", "BC", "->", "replaceAllUsesWith", "(", "NewF", ")", ";", "Replacements", ".", "emplace_back", "(", "&", "F", ",", "NewF", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "*", "U", ".", "getUser", "(", ")", "->", "getType", "(", ")", "<<", "\"\\n\"", ";", "U", ".", "getUser", "(", ")", "->", "dump", "(", ")", ";", "report_fatal_error", "(", "\"unexpected use of prototypeless function: \"", "+", "F", ".", "getName", "(", ")", "+", "\"\\n\"", ")", ";", "}", "}", "}", "for", "(", "auto", "&", "Pair", ":", "Replacements", ")", "{", "Function", "*", "Old", "=", "Pair", ".", "first", ";", "Function", "*", "New", "=", "Pair", ".", "second", ";", "Old", "->", "eraseFromParent", "(", ")", ";", "M", ".", "getFunctionList", "(", ")", ".", "push_back", "(", "New", ")", ";", "}", "return", "!", "Replacements", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"runnning AddMissingPrototypes\\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\"", "\"no-prototype\"", "\"could not derive a function prototype from usage: \"", "\"\\n\"", "\"Prototypeless function used with conflicting signatures: \"", "\"\\n\"", "\"unexpected use of prototypeless function: \"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "rs6000_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "int", "regsize", "=", "(", "TARGET_32BIT", ")", "?", "4", ":", "8", ";", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "rtx", "ctx_reg", "=", "force_reg", "(", "Pmode", ",", "cxt", ")", ";", "rtx", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "m_tramp", ",", "0", ")", ")", ";", "switch", "(", "DEFAULT_ABI", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "ABI_AIX", ":", "{", "rtx", "fnmem", ",", "fn_reg", ",", "toc_reg", ";", "if", "(", "!", "TARGET_POINTERS_TO_NESTED_FUNCTIONS", ")", "error", "(", "\"You cannot take the address of a nested function if you use \"", "\"the -mno-pointers-to-nested-functions option.\"", ")", ";", "fnmem", "=", "gen_const_mem", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "fnaddr", ")", ")", ";", "fn_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "toc_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "m_tramp", "=", "replace_equiv_address", "(", "m_tramp", ",", "addr", ")", ";", "emit_move_insn", "(", "fn_reg", ",", "MEM_PLUS", "(", "fnmem", ",", "0", ")", ")", ";", "emit_move_insn", "(", "toc_reg", ",", "MEM_PLUS", "(", "fnmem", ",", "regsize", ")", ")", ";", "emit_move_insn", "(", "MEM_PLUS", "(", "m_tramp", ",", "0", ")", ",", "fn_reg", ")", ";", "emit_move_insn", "(", "MEM_PLUS", "(", "m_tramp", ",", "regsize", ")", ",", "toc_reg", ")", ";", "emit_move_insn", "(", "MEM_PLUS", "(", "m_tramp", ",", "2", "*", "regsize", ")", ",", "ctx_reg", ")", ";", "}", "break", ";", "case", "ABI_ELFv2", ":", "case", "ABI_DARWIN", ":", "case", "ABI_V4", ":", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__trampoline_setup\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "addr", ",", "Pmode", ",", "GEN_INT", "(", "rs6000_trampoline_size", "(", ")", ")", ",", "SImode", ",", "fnaddr", ",", "Pmode", ",", "ctx_reg", ",", "Pmode", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "powerpcspe", "4", "8", "0", "0", "\"You cannot take the address of a nested function if you use \"", "\"the -mno-pointers-to-nested-functions option.\"", "0", "0", "2", "\"__trampoline_setup\"" ]

[]

[ "<s>", "VSETVLIInfo", "merge", "(", "const", "VSETVLIInfo", "&", "Other", ")", "const", "{", "assert", "(", "isValid", "(", ")", "&&", "\"Can only merge with a valid VSETVLInfo\"", ")", ";", "if", "(", "!", "Other", ".", "isValid", "(", ")", ")", "return", "*", "this", ";", "if", "(", "isCompatible", "(", "Other", ",", "true", ")", ")", "return", "*", "this", ";", "return", "Other", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "RISCV", "\"Can only merge with a valid VSETVLInfo\"" ]

[]

[ "<s>", "static", "rtx", "visium_function_arg", "(", "cumulative_args_t", "pcum_v", ",", "enum", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "size", ";", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "size", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "mode", "==", "VOIDmode", ")", "return", "GEN_INT", "(", "0", ")", ";", "if", "(", "TARGET_FPU", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", "*", "2", ")", ")", ")", "{", "if", "(", "ca", "->", "frcount", "+", "size", "<=", "MAX_ARGS_IN_FP_REGISTERS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "FP_ARG_FIRST", "+", "ca", "->", "frcount", ")", ";", "else", "return", "NULL_RTX", ";", "}", "if", "(", "ca", "->", "grcount", "+", "size", "<=", "MAX_ARGS_IN_GP_REGISTERS", ")", "return", "gen_rtx_REG", "(", "mode", ",", "ca", "->", "grcount", "+", "GP_ARG_FIRST", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Define", "how", "arguments", "are", "passed", ".", "A", "range", "of", "general", "registers", "and", "floating", "registers", "is", "available", "for", "passing", "arguments", ".", "When", "the", "class", "of", "registers", "which", "an", "argument", "would", "normally", "use", "is", "exhausted", ",", "that", "argument", ",", "is", "passed", "in", "the", "overflow", "region", "of", "the", "stack", ".", "No", "argument", "is", "split", "between", "registers", "and", "stack", ".", "Arguments", "of", "type", "float", "or", "_Complex", "float", "go", "in", "FP", "registers", "if", "FP", "hardware", "is", "available", ".", "If", "there", "is", "no", "FP", "hardware", ",", "arguments", "of", "type", "float", "go", "in", "general", "registers", ".", "All", "other", "arguments", "are", "passed", "in", "general", "registers", "." ]

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

[]

[ "<s>", "MCELFStreamer", "&", "getStreamer", "(", ")", "{", "return", "static_cast", "<", "MCELFStreamer", "&", ">", "(", "Streamer", ")", ";", "}", "</s>" ]

[ "Return", "the", "output", "streamer", "for", "the", "assembler", "." ]

[ "GBZ80" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "{", "SDValue", "Result", "=", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "(", "!", "Result", ".", "getNode", "(", ")", "||", "Result", ".", "getNode", "(", ")", "->", "getNumValues", "(", ")", "==", "2", ")", "&&", "\"Load should return a value and a chain\"", ")", ";", "return", "Result", ";", "}", "case", "ISD", "::", "FSIN", ":", "case", "ISD", "::", "FCOS", ":", "return", "LowerTrig", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerFDIV", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "return", "LowerATOMIC_CMP_SWAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "return", "LowerGlobalAddress", "(", "MFI", ",", "Op", ",", "DAG", ")", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "LowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADDRSPACECAST", ":", "return", "lowerADDRSPACECAST", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "lowerINSERT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "lowerINSERT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "lowerEXTRACT_VECTOR_ELT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "lowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "lowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_ROUND", ":", "return", "lowerFP_ROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "TRAP", ":", "return", "lowerTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DEBUGTRAP", ":", "return", "lowerDEBUGTRAP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FABS", ":", "case", "ISD", "::", "FNEG", ":", "case", "ISD", "::", "FCANONICALIZE", ":", "return", "splitUnaryVectorOp", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FMINNUM", ":", "case", "ISD", "::", "FMAXNUM", ":", "return", "lowerFMINNUM_FMAXNUM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "SMIN", ":", "case", "ISD", "::", "SMAX", ":", "case", "ISD", "::", "UMIN", ":", "case", "ISD", "::", "UMAX", ":", "case", "ISD", "::", "FADD", ":", "case", "ISD", "::", "FMUL", ":", "case", "ISD", "::", "FMINNUM_IEEE", ":", "case", "ISD", "::", "FMAXNUM_IEEE", ":", "return", "splitBinaryVectorOp", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU", "ISD::BRCOND", "ISD::RETURNADDR", "ISD::LOAD", "2", "\"Load should return a value and a chain\"", "ISD::FSIN", "ISD::FCOS", "ISD::SELECT", "ISD::FDIV", "ISD::ATOMIC_CMP_SWAP", "ISD::STORE", "ISD::GlobalAddress", "SI", "SI", "ISD::INTRINSIC_WO_CHAIN", "SI", "ISD::INTRINSIC_W_CHAIN", "SI", "ISD::INTRINSIC_VOID", "SI", "ISD::ADDRSPACECAST", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_VECTOR_ELT", "ISD::VECTOR_SHUFFLE", "ISD::BUILD_VECTOR", "ISD::FP_ROUND", "ISD::TRAP", "ISD::DEBUGTRAP", "ISD::FABS", "ISD::FNEG", "ISD::FCANONICALIZE", "ISD::FMINNUM", "ISD::FMAXNUM", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ADD", "ISD::SUB", "ISD::MUL", "ISD::SMIN", "ISD::SMAX", "ISD::UMIN", "ISD::UMAX", "ISD::FADD", "ISD::FMUL", "ISD::FMINNUM_IEEE", "ISD::FMAXNUM_IEEE" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", ";", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "bool", "AfterFPPop", "=", "Opc", "==", "X86", "::", "TAILJMPm64", "||", "Opc", "==", "X86", "::", "TAILJMPm", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "getBaseRegister", "(", ")", ")", ";", "else", "if", "(", "needsStackRealignment", "(", "MF", ")", ")", "BasePtr", "=", "(", "FrameIndex", "<", "0", "?", "FramePtr", ":", "StackPtr", ")", ";", "else", "if", "(", "AfterFPPop", ")", "BasePtr", "=", "StackPtr", ";", "else", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "int", "FIOffset", ";", "if", "(", "AfterFPPop", ")", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FIOffset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", "-", "TFI", "->", "getOffsetOfLocalArea", "(", ")", ";", "}", "else", "FIOffset", "=", "TFI", "->", "getFrameIndexOffset", "(", "MF", ",", "FrameIndex", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "X86::TAILJMPm64", "X86::TAILJMPm", "0", "0", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "3", "3", "3" ]

[]

[ "<s>", "const", "char", "*", "rs6000_output_load_multiple", "(", "rtx", "operands", "[", "3", "]", ")", "{", "int", "i", ",", "j", ";", "int", "words", "=", "XVECLEN", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "rtx", "xop", "[", "10", "]", ";", "if", "(", "XVECLEN", "(", "operands", "[", "0", "]", ",", "0", ")", "==", "1", ")", "return", "\"lwz %2,0(%1)\"", ";", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "i", "++", ")", "if", "(", "refers_to_regno_p", "(", "REGNO", "(", "operands", "[", "2", "]", ")", "+", "i", ",", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "i", "==", "words", "-", "1", ")", "{", "xop", "[", "0", "]", "=", "GEN_INT", "(", "4", "*", "(", "words", "-", "1", ")", ")", ";", "xop", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "xop", "[", "2", "]", "=", "operands", "[", "2", "]", ";", "output_asm_insn", "(", "\"lswi %2,%1,%0\\n\\tlwz %1,%0(%1)\"", ",", "xop", ")", ";", "return", "\"\"", ";", "}", "else", "if", "(", "i", "==", "0", ")", "{", "xop", "[", "0", "]", "=", "GEN_INT", "(", "4", "*", "(", "words", "-", "1", ")", ")", ";", "xop", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "xop", "[", "2", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "operands", "[", "2", "]", ")", "+", "1", ")", ";", "output_asm_insn", "(", "\"addi %1,%1,4\\n\\tlswi %2,%1,%0\\n\\tlwz %1,-4(%1)\"", ",", "xop", ")", ";", "return", "\"\"", ";", "}", "else", "{", "for", "(", "j", "=", "0", ";", "j", "<", "words", ";", "j", "++", ")", "if", "(", "j", "!=", "i", ")", "{", "xop", "[", "0", "]", "=", "GEN_INT", "(", "j", "*", "4", ")", ";", "xop", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "xop", "[", "2", "]", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "operands", "[", "2", "]", ")", "+", "j", ")", ";", "output_asm_insn", "(", "\"lwz %2,%0(%1)\"", ",", "xop", ")", ";", "}", "xop", "[", "0", "]", "=", "GEN_INT", "(", "i", "*", "4", ")", ";", "xop", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "output_asm_insn", "(", "\"lwz %1,%0(%1)\"", ",", "xop", ")", ";", "return", "\"\"", ";", "}", "}", "return", "\"lswi %2,%1,%N0\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "perform", "a", "load_multiple", "operation", ".", "operands", "[", "0", "]", "is", "the", "vector", ".", "operands", "[", "1", "]", "is", "the", "source", "address", ".", "operands", "[", "2", "]", "is", "the", "first", "destination", "register", "." ]

[ "powerpcspe", "3", "0", "0", "10", "0", "0", "1", "\"lwz %2,0(%1)\"", "0", "2", "1", "1", "0", "4", "1", "1", "1", "2", "2", "\"lswi %2,%1,%0\\n\\tlwz %1,%0(%1)\"", "\"\"", "0", "0", "4", "1", "1", "1", "2", "2", "1", "\"addi %1,%1,4\\n\\tlswi %2,%1,%0\\n\\tlwz %1,-4(%1)\"", "\"\"", "0", "0", "4", "1", "1", "2", "2", "\"lwz %2,%0(%1)\"", "0", "4", "1", "1", "\"lwz %1,%0(%1)\"", "\"\"", "\"lswi %2,%1,%N0\"" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "const", "Type", "*", "Ty", ")", "const", "{", "if", "(", "AM", ".", "BaseOffs", "<=", "-", "(", "1LL", "<<", "16", ")", "||", "AM", ".", "BaseOffs", ">=", "(", "1LL", "<<", "16", ")", "-", "1", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", "&&", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "case", "2", ":", "if", "(", "AM", ".", "HasBaseReg", "||", "AM", ".", "BaseOffs", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1LL", "16", "1LL", "16", "1", "0", "1", "2" ]

[]

[ "<s>", "static", "void", "replace_swapped_aligned_store", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx_insn", "*", "store_insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "store_insn", ")", ";", "gcc_assert", "(", "insn_entry", "[", "uid", "]", ".", "is_swap", "&&", "insn_entry", "[", "uid", "]", ".", "is_store", ")", ";", "rtx", "body", "=", "PATTERN", "(", "store_insn", ")", ";", "rtx", "dest_address", "=", "XEXP", "(", "SET_DEST", "(", "body", ")", ",", "0", ")", ";", "rtx", "swap_reg", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "dest_address", ")", "||", "rs6000_sum_of_two_registers_p", "(", "dest_address", ")", ")", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "store_insn", ")", ";", "df_ref", "use", ";", "rtx_insn", "*", "swap_insn", "=", "NULL", ";", "unsigned", "uid2", "=", "0", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "use", ")", ",", "swap_reg", ")", ")", "continue", ";", "gcc_assert", "(", "def_link", "&&", "def_link", "->", "ref", "&&", "!", "def_link", "->", "next", "&&", "!", "DF_REF_IS_ARTIFICIAL", "(", "def_link", "->", "ref", ")", ")", ";", "swap_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "uid2", "=", "INSN_UID", "(", "swap_insn", ")", ";", "gcc_assert", "(", "insn_entry", "[", "uid2", "]", ".", "is_swap", "&&", "!", "insn_entry", "[", "uid2", "]", ".", "is_load", "&&", "!", "insn_entry", "[", "uid2", "]", ".", "is_store", ")", ";", "break", ";", "}", "gcc_assert", "(", "swap_insn", ")", ";", "rtx", "set", "=", "single_set", "(", "store_insn", ")", ";", "gcc_assert", "(", "set", ")", ";", "rtx", "dest_exp", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "src_exp", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "dest_exp", ")", ";", "gcc_assert", "(", "MEM_P", "(", "dest_exp", ")", ")", ";", "gcc_assert", "(", "MEM_ALIGN", "(", "dest_exp", ")", ">=", "128", ")", ";", "rtx", "stvx", ";", "stvx", "=", "rs6000_gen_stvx", "(", "mode", ",", "dest_exp", ",", "src_exp", ")", ";", "rtx_insn", "*", "new_insn", "=", "emit_insn_before", "(", "stvx", ",", "store_insn", ")", ";", "rtx", "new_body", "=", "PATTERN", "(", "new_insn", ")", ";", "gcc_assert", "(", "(", "GET_CODE", "(", "new_body", ")", "==", "SET", ")", "&&", "MEM_P", "(", "SET_DEST", "(", "new_body", ")", ")", ")", ";", "set_block_for_insn", "(", "new_insn", ",", "BLOCK_FOR_INSN", "(", "store_insn", ")", ")", ";", "df_insn_rescan", "(", "new_insn", ")", ";", "df_insn_delete", "(", "store_insn", ")", ";", "remove_insn", "(", "store_insn", ")", ";", "store_insn", "->", "set_deleted", "(", ")", ";", "uid2", "=", "INSN_UID", "(", "swap_insn", ")", ";", "mark_swaps_for_removal", "(", "insn_entry", ",", "uid2", ")", ";", "replace_swap_with_copy", "(", "insn_entry", ",", "uid2", ")", ";", "}", "</s>" ]

[ "Given", "that", "STORE_INSN", "represents", "an", "aligned", "store-with-swap", "of", "a", "swapped", "value", ",", "replace", "the", "store", "with", "an", "aligned", "store", "(", "without", "swap", ")", "and", "replace", "the", "swap", "with", "a", "copy", "insn", "." ]

[ "rs6000", "0", "0", "0", "0", "128" ]

[]

[ "<s>", "const", "TargetFrameLowering", "::", "SpillSlot", "*", "SystemZFrameLowering", "::", "getCalleeSavedSpillSlots", "(", "unsigned", "&", "NumEntries", ")", "const", "{", "NumEntries", "=", "array_lengthof", "(", "SpillOffsetTable", ")", ";", "return", "SpillOffsetTable", ";", "}", "</s>" ]

[ "getCalleeSavedSpillSlots", "-", "This", "method", "returns", "a", "pointer", "to", "an", "array", "of", "pairs", ",", "that", "contains", "an", "entry", "for", "each", "callee", "saved", "register", "that", "must", "be", "spilled", "to", "a", "particular", "stack", "location", "if", "it", "is", "spilled", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "std", "::", "string", "NewOpcode", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Plus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "NewOpcode", "=", "Name", ";", "NewOpcode", "+=", "'+'", ";", "Name", "=", "NewOpcode", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Minus", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "NewOpcode", "=", "Name", ";", "NewOpcode", "+=", "'-'", ";", "Name", "=", "NewOpcode", ";", "}", "size_t", "Dot", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "0", ",", "Dot", ")", ";", "if", "(", "!", "NewOpcode", ".", "empty", "(", ")", ")", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateTokenWithStringCopy", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "else", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "if", "(", "Dot", "!=", "StringRef", "::", "npos", ")", "{", "SMLoc", "DotLoc", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "+", "Dot", ")", ";", "StringRef", "DotStr", "=", "Name", ".", "slice", "(", "Dot", ",", "StringRef", "::", "npos", ")", ";", "if", "(", "!", "NewOpcode", ".", "empty", "(", ")", ")", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateTokenWithStringCopy", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "else", "Operands", ".", "push_back", "(", "PPCOperand", "::", "CreateToken", "(", "DotStr", ",", "DotLoc", ",", "isPPC64", "(", ")", ")", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "if", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "PPC", "::", "FeatureBookE", "]", "&&", "Operands", ".", "size", "(", ")", "==", "4", "&&", "(", "Name", "==", "\"dcbt\"", "||", "Name", "==", "\"dcbtst\"", ")", ")", "{", "std", "::", "swap", "(", "Operands", "[", "1", "]", ",", "Operands", "[", "3", "]", ")", ";", "std", "::", "swap", "(", "Operands", "[", "2", "]", ",", "Operands", "[", "1", "]", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "PowerPC", "PPC", "0", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC::FeatureBookE", "4", "\"dcbt\"", "\"dcbtst\"", "1", "3", "2", "1" ]

[]

[ "<s>", "unsigned", "getMaxNumElements", "(", "ElementCount", "VF", ")", "const", "{", "if", "(", "!", "VF", ".", "isScalable", "(", ")", ")", "return", "VF", ".", "getFixedValue", "(", ")", ";", "Optional", "<", "unsigned", ">", "MaxNumVScale", "=", "getMaxVScale", "(", ")", ";", "assert", "(", "MaxNumVScale", "&&", "\"Expected valid max vscale value\"", ")", ";", "return", "*", "MaxNumVScale", "*", "VF", ".", "getKnownMinValue", "(", ")", ";", "}", "</s>" ]

[ "Try", "to", "return", "an", "estimate", "cost", "factor", "that", "can", "be", "used", "as", "a", "multiplier", "when", "scalarizing", "an", "operation", "for", "a", "vector", "with", "ElementCount", "VF", "." ]

[ "AArch64", "\"Expected valid max vscale value\"" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "unsigned", "ExtraPredCycles", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "bool", "sh_expand_strlen", "(", "rtx", "*", "operands", ")", "{", "rtx", "addr1", "=", "operands", "[", "1", "]", ";", "rtx", "current_addr", "=", "copy_addr_to_reg", "(", "XEXP", "(", "addr1", ",", "0", ")", ")", ";", "rtx", "start_addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "rtx", "tmp0", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "tmp1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "L_return", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "L_loop_byte", "=", "gen_label_rtx", "(", ")", ";", "rtx", "jump", ";", "rtx_code_label", "*", "L_loop_long", "=", "gen_label_rtx", "(", ")", ";", "rtx_code_label", "*", "L_end_loop_long", "=", "gen_label_rtx", "(", ")", ";", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "GEN_INT", "(", "-", "1", ")", ")", ";", "emit_move_insn", "(", "start_addr", ",", "current_addr", ")", ";", "if", "(", "align", "<", "4", ")", "{", "emit_insn", "(", "gen_tstsi_t", "(", "current_addr", ",", "GEN_INT", "(", "3", ")", ")", ")", ";", "jump", "=", "emit_jump_insn", "(", "gen_branch_false", "(", "L_loop_byte", ")", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "prob_likely", ")", ";", "}", "emit_move_insn", "(", "tmp0", ",", "operands", "[", "2", "]", ")", ";", "addr1", "=", "adjust_automodify_address", "(", "addr1", ",", "SImode", ",", "current_addr", ",", "0", ")", ";", "emit_label", "(", "L_loop_long", ")", ";", "emit_move_insn", "(", "tmp1", ",", "addr1", ")", ";", "emit_move_insn", "(", "current_addr", ",", "plus_constant", "(", "Pmode", ",", "current_addr", ",", "4", ")", ")", ";", "emit_insn", "(", "gen_cmpstr_t", "(", "tmp0", ",", "tmp1", ")", ")", ";", "jump", "=", "emit_jump_insn", "(", "gen_branch_false", "(", "L_loop_long", ")", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "prob_likely", ")", ";", "emit_label", "(", "L_end_loop_long", ")", ";", "emit_move_insn", "(", "current_addr", ",", "plus_constant", "(", "Pmode", ",", "current_addr", ",", "-", "4", ")", ")", ";", "addr1", "=", "adjust_address", "(", "addr1", ",", "QImode", ",", "0", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "{", "emit_insn", "(", "gen_extendqisi2", "(", "tmp1", ",", "addr1", ")", ")", ";", "emit_move_insn", "(", "current_addr", ",", "plus_constant", "(", "Pmode", ",", "current_addr", ",", "1", ")", ")", ";", "emit_insn", "(", "gen_cmpeqsi_t", "(", "tmp1", ",", "const0_rtx", ")", ")", ";", "jump", "=", "emit_jump_insn", "(", "gen_branch_true", "(", "L_return", ")", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "prob_likely", ")", ";", "}", "emit_barrier_after", "(", "jump", ")", ";", "emit_label", "(", "L_loop_byte", ")", ";", "emit_insn", "(", "gen_extendqisi2", "(", "tmp1", ",", "addr1", ")", ")", ";", "emit_move_insn", "(", "current_addr", ",", "plus_constant", "(", "Pmode", ",", "current_addr", ",", "1", ")", ")", ";", "emit_insn", "(", "gen_cmpeqsi_t", "(", "tmp1", ",", "const0_rtx", ")", ")", ";", "jump", "=", "emit_jump_insn", "(", "gen_branch_false", "(", "L_loop_byte", ")", ")", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "prob_likely", ")", ";", "emit_label", "(", "L_return", ")", ";", "emit_insn", "(", "gen_addsi3", "(", "start_addr", ",", "start_addr", ",", "GEN_INT", "(", "1", ")", ")", ")", ";", "emit_insn", "(", "gen_subsi3", "(", "operands", "[", "0", "]", ",", "current_addr", ",", "start_addr", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "code", "to", "perform", "a", "strlen", ".", "OPERANDS", "[", "0", "]", "is", "the", "destination", ".", "OPERANDS", "[", "1", "]", "is", "the", "string", ".", "OPERANDS", "[", "2", "]", "is", "the", "char", "to", "search", ".", "OPERANDS", "[", "3", "]", "is", "the", "alignment", "." ]

[ "sh", "1", "0", "3", "0", "1", "4", "3", "2", "0", "4", "4", "0", "0", "4", "1", "1", "1", "0" ]

[]

[ "<s>", "void", "Z80AsmPrinter", "::", "emitInlineAsmEnd", "(", "const", "MCSubtargetInfo", "&", "StartInfo", ",", "const", "MCSubtargetInfo", "*", "EndInfo", ")", "const", "{", "return", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "!=", "Triple", "::", "ez80", ")", "{", "return", ";", "}", "bool", "Was16", "=", "isCode16", "(", "StartInfo", ".", "getTargetTriple", "(", ")", ")", ";", "if", "(", "!", "EndInfo", "||", "Was16", "!=", "isCode16", "(", "EndInfo", "->", "getTargetTriple", "(", ")", ")", ")", "{", "OutStreamer", "->", "EmitAssemblerFlag", "(", "Was16", "?", "MCAF_Code16", ":", "MCAF_Code24", ")", ";", "}", "}", "</s>" ]

[ "Let", "the", "target", "do", "anything", "it", "needs", "to", "do", "after", "emitting", "inlineasm", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "case", "RISCV", "::", "PseudoLLA", ":", "case", "RISCV", "::", "PseudoLA", ":", "case", "RISCV", "::", "PseudoLA_TLS_IE", ":", "case", "RISCV", "::", "PseudoLA_TLS_GD", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "RISCV::PseudoLLA", "RISCV::PseudoLA", "RISCV::PseudoLA_TLS_IE", "RISCV::PseudoLA_TLS_GD", "8", "RISCV", "0" ]

[]

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

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "void", "rs6000_emit_vector_select", "(", "rtx", "dest", ",", "rtx", "op1", ",", "rtx", "op2", ",", "rtx", "mask", ")", "{", "rtx", "t", ",", "temp", ";", "enum", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "int", "vsel_insn_index", "=", "get_vsel_insn", "(", "GET_MODE", "(", "dest", ")", ")", ";", "temp", "=", "gen_reg_rtx", "(", "dest_mode", ")", ";", "t", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "temp", ",", "gen_rtx_UNSPEC", "(", "dest_mode", ",", "gen_rtvec", "(", "3", ",", "op2", ",", "op1", ",", "mask", ")", ",", "vsel_insn_index", ")", ")", ";", "emit_insn", "(", "t", ")", ";", "emit_move_insn", "(", "dest", ",", "temp", ")", ";", "return", ";", "}", "</s>" ]

[ "Emit", "vector", "select", "insn", "where", "DEST", "is", "destination", "using", "operands", "OP1", ",", "OP2", "and", "MASK", "." ]

[ "rs6000", "3" ]

[]

[ "<s>", "const", "SIRegisterInfo", "&", "SIInstrInfo", "::", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "TargetRegisterClass", "*", "MandarinRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "&", "MD", "::", "GenericRegsRegClass", ";", "}", "</s>" ]

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

[ "Mandarin", "MD::GenericRegsRegClass" ]

[]

[ "<s>", "MachineBasicBlock", "*", "OR1KTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected instr type to insert\"", ")", ";", "case", "OR1K", "::", "Select", ":", "case", "OR1K", "::", "Selectf32", ":", "return", "emitSelect", "(", "MI", ",", "BB", ")", ";", "case", "OR1K", "::", "ATOMIC_LOAD_ADD_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "OR1K", "::", "ADD", ")", ";", "case", "OR1K", "::", "ATOMIC_LOAD_AND_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "OR1K", "::", "AND", ")", ";", "case", "OR1K", "::", "ATOMIC_LOAD_OR_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "OR1K", "::", "OR", ")", ";", "case", "OR1K", "::", "ATOMIC_LOAD_XOR_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "OR1K", "::", "XOR", ")", ";", "case", "OR1K", "::", "ATOMIC_LOAD_NAND_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "0", ",", "true", ")", ";", "case", "OR1K", "::", "ATOMIC_LOAD_SUB_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "OR1K", "::", "SUB", ")", ";", "case", "OR1K", "::", "ATOMIC_SWAP_I32", ":", "return", "emitAtomicBinary", "(", "MI", ",", "BB", ",", "0", ")", ";", "case", "OR1K", "::", "ATOMIC_CMP_SWAP_I32", ":", "return", "emitAtomicCmpSwap", "(", "MI", ",", "BB", ")", ";", "}", "}", "</s>" ]

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

[ "OR1K", "OR1K", "\"Unexpected instr type to insert\"", "OR1K::Select", "OR1K::Selectf32", "OR1K::ATOMIC_LOAD_ADD_I32", "OR1K::ADD", "OR1K::ATOMIC_LOAD_AND_I32", "OR1K::AND", "OR1K::ATOMIC_LOAD_OR_I32", "OR1K::OR", "OR1K::ATOMIC_LOAD_XOR_I32", "OR1K::XOR", "OR1K::ATOMIC_LOAD_NAND_I32", "0", "OR1K::ATOMIC_LOAD_SUB_I32", "OR1K::SUB", "OR1K::ATOMIC_SWAP_I32", "0", "OR1K::ATOMIC_CMP_SWAP_I32" ]

[]

[ "<s>", "int", "NVPTXTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "TTI", "::", "OperandValueKind", "Opd1Info", ",", "TTI", "::", "OperandValueKind", "Opd2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ",", "const", "Instruction", "*", "CxtI", ")", "{", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "switch", "(", "ISD", ")", "{", "default", ":", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "XOR", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "AND", ":", "if", "(", "LT", ".", "second", ".", "SimpleTy", "==", "MVT", "::", "i64", ")", "return", "2", "*", "LT", ".", "first", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "CostKind", ",", "Opd1Info", ",", "Opd2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::MUL", "ISD::XOR", "ISD::OR", "ISD::AND", "MVT::i64", "2" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isVectorClearMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "Mask", ",", "MVT", "VT", ")", "const", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "NumElts", "==", "2", ")", "return", "true", ";", "if", "(", "NumElts", "==", "4", "&&", "VT", ".", "getSizeInBits", "(", ")", "==", "128", ")", "{", "return", "(", "isMOVLMask", "(", "Mask", ",", "VT", ")", "||", "isCommutedMOVLMask", "(", "Mask", ",", "VT", ",", "true", ")", "||", "isSHUFPMask", "(", "Mask", ",", "VT", ")", "||", "isCommutedSHUFPMask", "(", "Mask", ",", "VT", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Similar", "to", "isShuffleMaskLegal", "." ]

[ "X86", "X86", "2", "4", "128" ]

[]

[ "<s>", "void", "LC2200FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "assert", "(", "&", "MF", ".", "front", "(", ")", "==", "&", "MBB", "&&", "\"Shrink-wrapping not yet supported\"", ")", ";", "bool", "hasFramePointer", "=", "hasFP", "(", "MF", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "LC2200InstrInfo", "*", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "&&", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "report_fatal_error", "(", "\"RISC-V backend can't currently handle functions that need stack \"", "\"realignment and have variable sized objects\"", ")", ";", "}", "Register", "FPReg", "=", "LC2200", "::", "fp", ";", "Register", "SPReg", "=", "LC2200", "::", "sp", ";", "DebugLoc", "DL", ";", "determineFrameLayout", "(", "MF", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "hasFramePointer", ")", "StackSize", "++", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "-", "StackSize", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createDefCfaOffset", "(", "nullptr", ",", "-", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "if", "(", "hasFramePointer", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "LC2200", "::", "SW", ")", ")", ".", "addReg", "(", "LC2200", "::", "fp", ")", ".", "addReg", "(", "LC2200", "::", "sp", ")", ".", "addImm", "(", "StackSize", "-", "1", ")", ";", "}", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "std", "::", "advance", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "for", "(", "const", "auto", "&", "Entry", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "Entry", ".", "getFrameIdx", "(", ")", ")", ";", "Register", "Reg", "=", "Entry", ".", "getReg", "(", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "RI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "if", "(", "hasFramePointer", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", "->", "get", "(", "LC2200", "::", "ADD", ")", ")", ".", "addReg", "(", "LC2200", "::", "fp", ")", ".", "addReg", "(", "LC2200", "::", "sp", ")", ".", "addReg", "(", "LC2200", "::", "zero", ")", ";", "const", "LC2200RegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "llvm_unreachable", "(", "\"cannot realign\"", ")", ";", "}", "}", "}", "</s>" ]

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

[ "LC2200", "LC2200", "\"Shrink-wrapping not yet supported\"", "LC2200", "LC2200", "\"RISC-V backend can't currently handle functions that need stack \"", "\"realignment and have variable sized objects\"", "LC2200::fp", "LC2200::sp", "0", "LC2200::SW", "LC2200::fp", "LC2200::sp", "1", "LC2200::ADD", "LC2200::fp", "LC2200::sp", "LC2200::zero", "LC2200", "\"cannot realign\"" ]

[]

[ "<s>", "LoongArchSubtarget", "&", "LoongArchSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "TuneCPU", ",", "StringRef", "FS", ",", "StringRef", "ABIName", ")", "{", "bool", "Is64Bit", "=", "TT", ".", "isArch64Bit", "(", ")", ";", "if", "(", "CPU", ".", "empty", "(", ")", ")", "CPU", "=", "Is64Bit", "?", "\"generic-la64\"", ":", "\"generic-la32\"", ";", "if", "(", "TuneCPU", ".", "empty", "(", ")", ")", "TuneCPU", "=", "CPU", ";", "ParseSubtargetFeatures", "(", "CPU", ",", "TuneCPU", ",", "FS", ")", ";", "if", "(", "Is64Bit", ")", "{", "GRLenVT", "=", "MVT", "::", "i64", ";", "GRLen", "=", "64", ";", "}", "TargetABI", "=", "Is64Bit", "?", "LoongArchABI", "::", "ABI_LP64D", ":", "LoongArchABI", "::", "ABI_ILP32D", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "LoongArch", "LoongArch", "LoongArch", "\"generic-la64\"", "\"generic-la32\"", "MVT::i64", "64", "LoongArchABI::ABI_LP64D", "LoongArchABI::ABI_ILP32D" ]

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "if", "(", "MBlazeFI", "->", "needGPSaveRestore", "(", ")", ")", "MFI", "->", "setObjectOffset", "(", "MBlazeFI", "->", "getGPFI", "(", ")", ",", "MBlazeFI", "->", "getGPStackOffset", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "BTFDebug", "::", "beginFunctionImpl", "(", "const", "MachineFunction", "*", "MF", ")", "{", "auto", "*", "SP", "=", "MF", "->", "getFunction", "(", ")", ".", "getSubprogram", "(", ")", ";", "auto", "*", "Unit", "=", "SP", "->", "getUnit", "(", ")", ";", "if", "(", "Unit", "->", "getEmissionKind", "(", ")", "==", "DICompileUnit", "::", "NoDebug", ")", "{", "SkipInstruction", "=", "true", ";", "return", ";", "}", "SkipInstruction", "=", "false", ";", "if", "(", "MapDefNotCollected", ")", "{", "processGlobals", "(", "true", ")", ";", "MapDefNotCollected", "=", "false", ";", "}", "std", "::", "unordered_map", "<", "uint32_t", ",", "StringRef", ">", "FuncArgNames", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "{", "visitTypeEntry", "(", "DV", "->", "getType", "(", ")", ")", ";", "FuncArgNames", "[", "Arg", "]", "=", "DV", "->", "getName", "(", ")", ";", "}", "}", "}", "uint32_t", "ProtoTypeId", ";", "visitSubroutineType", "(", "SP", "->", "getType", "(", ")", ",", "true", ",", "FuncArgNames", ",", "ProtoTypeId", ")", ";", "uint8_t", "Scope", "=", "SP", "->", "isLocalToUnit", "(", ")", "?", "BTF", "::", "FUNC_STATIC", ":", "BTF", "::", "FUNC_GLOBAL", ";", "auto", "FuncTypeEntry", "=", "std", "::", "make_unique", "<", "BTFTypeFunc", ">", "(", "SP", "->", "getName", "(", ")", ",", "ProtoTypeId", ",", "Scope", ")", ";", "uint32_t", "FuncTypeId", "=", "addType", "(", "std", "::", "move", "(", "FuncTypeEntry", ")", ")", ";", "for", "(", "const", "DINode", "*", "DN", ":", "SP", "->", "getRetainedNodes", "(", ")", ")", "{", "if", "(", "const", "auto", "*", "DV", "=", "dyn_cast", "<", "DILocalVariable", ">", "(", "DN", ")", ")", "{", "uint32_t", "Arg", "=", "DV", "->", "getArg", "(", ")", ";", "if", "(", "Arg", ")", "processAnnotations", "(", "DV", "->", "getAnnotations", "(", ")", ",", "FuncTypeId", ",", "Arg", "-", "1", ")", ";", "}", "}", "processAnnotations", "(", "SP", "->", "getAnnotations", "(", ")", ",", "FuncTypeId", ",", "-", "1", ")", ";", "for", "(", "const", "auto", "&", "TypeEntry", ":", "TypeEntries", ")", "TypeEntry", "->", "completeType", "(", "*", "this", ")", ";", "MCSymbol", "*", "FuncLabel", "=", "Asm", "->", "getFunctionBegin", "(", ")", ";", "BTFFuncInfo", "FuncInfo", ";", "FuncInfo", ".", "Label", "=", "FuncLabel", ";", "FuncInfo", ".", "TypeId", "=", "FuncTypeId", ";", "if", "(", "FuncLabel", "->", "isInSection", "(", ")", ")", "{", "MCSection", "&", "Section", "=", "FuncLabel", "->", "getSection", "(", ")", ";", "const", "MCSectionELF", "*", "SectionELF", "=", "dyn_cast", "<", "MCSectionELF", ">", "(", "&", "Section", ")", ";", "assert", "(", "SectionELF", "&&", "\"Null section for Function Label\"", ")", ";", "SecNameOff", "=", "addString", "(", "SectionELF", "->", "getName", "(", ")", ")", ";", "}", "else", "{", "SecNameOff", "=", "addString", "(", "\".text\"", ")", ";", "}", "FuncInfoTable", "[", "SecNameOff", "]", ".", "push_back", "(", "FuncInfo", ")", ";", "}", "</s>" ]

[ "Gather", "pre-function", "debug", "information", "." ]

[ "BPF", "BTF::FUNC_STATIC", "BTF::FUNC_GLOBAL", "1", "1", "\"Null section for Function Label\"", "\".text\"" ]

[]

[ "<s>", "sh_extending_set_of_reg", "sh_find_extending_set_of_reg", "(", "rtx", "reg", ",", "rtx_insn", "*", "curr_insn", ")", "{", "if", "(", "reg", "==", "NULL", ")", "return", "sh_extending_set_of_reg", "(", "curr_insn", ")", ";", "if", "(", "SUBREG_P", "(", "reg", ")", ")", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "return", "sh_extending_set_of_reg", "(", "curr_insn", ")", ";", "sh_extending_set_of_reg", "result", "=", "sh_find_set_of_reg", "(", "reg", ",", "curr_insn", ",", "prev_nonnote_insn_bb", ",", "true", ")", ";", "if", "(", "result", ".", "set_src", "!=", "NULL", ")", "{", "if", "(", "GET_CODE", "(", "result", ".", "set_src", ")", "==", "SIGN_EXTEND", "||", "GET_CODE", "(", "result", ".", "set_src", ")", "==", "ZERO_EXTEND", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"explicitly sign/zero extended in insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "INSN_UID", "(", "result", ".", "insn", ")", ")", ";", "result", ".", "from_mode", "=", "GET_MODE", "(", "XEXP", "(", "result", ".", "set_src", ",", "0", ")", ")", ";", "result", ".", "ext_code", "=", "GET_CODE", "(", "result", ".", "set_src", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "result", ".", "set_src", ")", "&&", "(", "GET_MODE", "(", "result", ".", "set_src", ")", "==", "QImode", "||", "GET_MODE", "(", "result", ".", "set_src", ")", "==", "HImode", ")", "&&", "!", "sh_unspec_insn_p", "(", "result", ".", "insn", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"implicitly sign extended in insn %d\\n\"", ",", "REGNO", "(", "reg", ")", ",", "INSN_UID", "(", "result", ".", "insn", ")", ")", ";", "result", ".", "from_mode", "=", "GET_MODE", "(", "result", ".", "set_src", ")", ";", "result", ".", "ext_code", "=", "SIGN_EXTEND", ";", "}", "}", "return", "result", ";", "}", "</s>" ]

[ "Given", "a", "reg", "and", "the", "current", "insn", ",", "see", "if", "the", "value", "of", "the", "reg", "originated", "from", "a", "sign", "or", "zero", "extension", "and", "return", "the", "discovered", "information", "." ]

[ "sh", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"explicitly sign/zero extended in insn %d\\n\"", "0", "\"sh_find_extending_set_of_reg: reg %d is \"", "\"implicitly sign extended in insn %d\\n\"" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "if", "(", "convertAddSubFlagsOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", ";", "return", "false", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tMOVr", "&&", "!", "Subtarget", ".", "hasV6Ops", "(", ")", ")", "{", "if", "(", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "&&", "!", "ARM", "::", "hGPRRegClass", ".", "contains", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "{", "ErrInfo", "=", "\"Non-flag-setting Thumb1 mov is v6-only\"", ";", "return", "false", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP", "||", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", ")", "{", "for", "(", "int", "i", "=", "2", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "i", ")", ".", "isImplicit", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isReg", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "<", "ARM", "::", "R0", "||", "Reg", ">", "ARM", "::", "R7", ")", "{", "if", "(", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPUSH", "&&", "Reg", "==", "ARM", "::", "LR", ")", "&&", "!", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "tPOP_RET", "&&", "Reg", "==", "ARM", "::", "PC", ")", ")", "{", "ErrInfo", "=", "\"Unsupported register in Thumb1 push/pop\"", ";", "return", "false", ";", "}", "}", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "ARM", "::", "MVE_VMOV_q_rr", ")", "{", "assert", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "5", ")", ".", "isImm", "(", ")", ")", ";", "if", "(", "(", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "2", "&&", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "3", ")", "||", "MI", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", "!=", "MI", ".", "getOperand", "(", "5", ")", ".", "getImm", "(", ")", "+", "2", ")", "{", "ErrInfo", "=", "\"Incorrect array index for MVE_VMOV_q_rr\"", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "ARM", "ARM", "\"Pseudo flag setting opcodes only exist in Selection DAG\"", "ARM::tMOVr", "ARM::hGPRRegClass", "0", "ARM::hGPRRegClass", "1", "\"Non-flag-setting Thumb1 mov is v6-only\"", "ARM::tPUSH", "ARM::tPOP", "ARM::tPOP_RET", "2", "ARM::R0", "ARM::R7", "ARM::tPUSH", "ARM::LR", "ARM::tPOP_RET", "ARM::PC", "\"Unsupported register in Thumb1 push/pop\"", "ARM::MVE_VMOV_q_rr", "4", "5", "4", "2", "4", "3", "4", "5", "2", "\"Incorrect array index for MVE_VMOV_q_rr\"" ]

[]

[ "<s>", "static", "void", "alpha_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "bool", "onstack", "=", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ";", "int", "increment", "=", "onstack", "?", "6", ":", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ",", "named", ")", ";", "*", "cum", "+=", "increment", ";", "if", "(", "!", "onstack", "&&", "cum", "->", "num_args", "<", "6", ")", "cum", "->", "atypes", "[", "cum", "->", "num_args", "]", "=", "alpha_arg_type", "(", "mode", ")", ";", "cum", "->", "num_args", "+=", "increment", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "alpha", "6", "6" ]

[]

[ "<s>", "static", "inline", "int", "addsubcosts", "(", "rtx", "x", ")", "{", "if", "(", "GET_MODE", "(", "x", ")", "==", "SImode", ")", "{", "rtx", "op0", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "op0", ")", "==", "AND", "&&", "XEXP", "(", "op0", ",", "1", ")", "==", "const1_rtx", "&&", "(", "GET_CODE", "(", "op1", ")", "==", "PLUS", "||", "(", "GET_CODE", "(", "op1", ")", "==", "MULT", "&&", "XEXP", "(", "op1", ",", "1", ")", "==", "const2_rtx", ")", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MULT", "&&", "XEXP", "(", "op0", ",", "1", ")", "==", "const2_rtx", "&&", "GET_CODE", "(", "op1", ")", "==", "LSHIFTRT", "&&", "CONST_INT_P", "(", "XEXP", "(", "op1", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "op1", ",", "1", ")", ")", "==", "31", ")", "return", "1", ";", "}", "if", "(", "treg_set_expr", "(", "op1", ",", "SImode", ")", ")", "return", "1", ";", "if", "(", "treg_set_expr", "(", "op0", ",", "SImode", ")", ")", "return", "1", ";", "}", "const", "int", "cost_scale", "=", "!", "TARGET_SHMEDIA", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "UNITS_PER_WORD", "?", "2", ":", "1", ";", "if", "(", "REG_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "SUBREG", ")", "return", "1", "*", "cost_scale", ";", "if", "(", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "CONST_OK_FOR_ADD", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "1", "*", "cost_scale", ";", "if", "(", "TARGET_SHMEDIA", ")", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "return", "TARGET_SHMEDIA64", "?", "5", ":", "3", ";", "case", "CONST_INT", ":", "if", "(", "CONST_OK_FOR_I16", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "2", ";", "else", "if", "(", "CONST_OK_FOR_I16", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">>", "16", ")", ")", "return", "3", ";", "else", "if", "(", "CONST_OK_FOR_I16", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">>", "16", ")", ">>", "16", ")", ")", "return", "4", ";", "default", ":", "return", "5", ";", "}", "return", "3", "*", "cost_scale", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "an", "addition", "or", "a", "subtraction", "." ]

[ "sh", "0", "1", "1", "1", "1", "1", "1", "1", "31", "1", "1", "1", "2", "1", "1", "1", "1", "1", "1", "1", "1", "5", "3", "1", "2", "1", "16", "3", "1", "16", "16", "4", "5", "3" ]

[]

[ "<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", "(", "GET_MODE_SIZE", "(", "cmp_ops_mode", ")", "==", "64", ")", "{", "unsigned", "int", "nbits", "=", "GET_MODE_NUNITS", "(", "cmp_ops_mode", ")", ";", "cmp_mode", "=", "int_mode_for_size", "(", "nbits", ",", "0", ")", ".", "require", "(", ")", ";", "maskcmp", "=", "true", ";", "}", "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", "&&", "(", "code", "==", "GT", "||", "code", "==", "EQ", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "cmp_ops_mode", ")", "{", "case", "E_V64QImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv64qi3", ":", "gen_avx512bw_eqv64qi3_1", ";", "break", ";", "case", "E_V32HImode", ":", "gcc_assert", "(", "TARGET_AVX512BW", ")", ";", "gen", "=", "code", "==", "GT", "?", "gen_avx512bw_gtv32hi3", ":", "gen_avx512bw_eqv32hi3_1", ";", "break", ";", "case", "E_V16SImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv16si3", ":", "gen_avx512f_eqv16si3_1", ";", "break", ";", "case", "E_V8DImode", ":", "gen", "=", "code", "==", "GT", "?", "gen_avx512f_gtv8di3", ":", "gen_avx512f_eqv8di3_1", ";", "break", ";", "default", ":", "gen", "=", "NULL", ";", "}", "if", "(", "gen", ")", "{", "emit_insn", "(", "gen", "(", "dest", ",", "cmp_op0", ",", "cmp_op1", ")", ")", ";", "return", "dest", ";", "}", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "cmp_mode", ",", "cmp_op0", ",", "cmp_op1", ")", ";", "if", "(", "cmp_mode", "!=", "mode", "&&", "!", "maskcmp", ")", "{", "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", "64", "0" ]

[]

[ "<s>", "bool", "HexagonTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "!", "isSmallDataEnabled", "(", "TM", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Small data is not available.\\n\"", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Checking if value is in small-data, -G\"", "<<", "SmallDataThreshold", "<<", "\": \\\"\"", "<<", "GO", "->", "getName", "(", ")", "<<", "\"\\\": \"", ")", ";", "const", "GlobalVariable", "*", "GVar", "=", "dyn_cast", "<", "GlobalVariable", ">", "(", "GO", ")", ";", "if", "(", "!", "GVar", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, not a global variable\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "GVar", "->", "hasSection", "(", ")", ")", "{", "bool", "IsSmall", "=", "isSmallDataSection", "(", "GVar", "->", "getSection", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "(", "IsSmall", "?", "\"yes\"", ":", "\"no\"", ")", "<<", "\", has section: \"", "<<", "GVar", "->", "getSection", "(", ")", "<<", "'\\n'", ")", ";", "return", "IsSmall", ";", "}", "if", "(", "GVar", "->", "isConstant", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is a constant\\n\"", ")", ";", "return", "false", ";", "}", "bool", "IsLocal", "=", "GVar", "->", "hasLocalLinkage", "(", ")", ";", "if", "(", "!", "StaticsInSData", "&&", "IsLocal", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is static\\n\"", ")", ";", "return", "false", ";", "}", "Type", "*", "GType", "=", "GVar", "->", "getType", "(", ")", ";", "if", "(", "PointerType", "*", "PT", "=", "dyn_cast", "<", "PointerType", ">", "(", "GType", ")", ")", "GType", "=", "PT", "->", "getElementType", "(", ")", ";", "if", "(", "isa", "<", "ArrayType", ">", "(", "GType", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, is an array\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "StructType", "*", "ST", "=", "dyn_cast", "<", "StructType", ">", "(", "GType", ")", ")", "{", "if", "(", "ST", "->", "isOpaque", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has opaque type\\n\"", ")", ";", "return", "false", ";", "}", "}", "unsigned", "Size", "=", "GVar", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ".", "getTypeAllocSize", "(", "GType", ")", ";", "if", "(", "Size", "==", "0", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, has size 0\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "Size", ">", "SmallDataThreshold", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"no, size exceeds sdata threshold: \"", "<<", "Size", "<<", "'\\n'", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"yes\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Small data is not available.\\n\"", "\"Checking if value is in small-data, -G\"", "\": \\\"\"", "\"\\\": \"", "\"no, not a global variable\\n\"", "\"yes\"", "\"no\"", "\", has section: \"", "\"no, is a constant\\n\"", "\"no, is static\\n\"", "\"no, is an array\\n\"", "\"no, has opaque type\\n\"", "0", "\"no, has size 0\\n\"", "\"no, size exceeds sdata threshold: \"", "\"yes\\n\"" ]

[]

[ "<s>", "void", "h8300_expand_prologue", "(", "void", ")", "{", "int", "regno", ";", "int", "saved_regs", ";", "int", "n_regs", ";", "if", "(", "h8300_os_task_function_p", "(", "current_function_decl", ")", ")", "return", ";", "if", "(", "h8300_monitor_function_p", "(", "current_function_decl", ")", ")", "emit_insn", "(", "gen_monitor_prologue", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "push", "(", "HARD_FRAME_POINTER_REGNUM", ",", "true", ")", ";", "F", "(", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ",", "true", ")", ";", "}", "saved_regs", "=", "compute_saved_regs", "(", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "+=", "n_regs", ")", "{", "n_regs", "=", "1", ";", "if", "(", "saved_regs", "&", "(", "1", "<<", "regno", ")", ")", "{", "if", "(", "TARGET_H8300S", ")", "{", "if", "(", "(", "!", "TARGET_H8300SX", "||", "(", "regno", "&", "3", ")", "==", "0", ")", "&&", "(", "(", "saved_regs", ">>", "regno", ")", "&", "0x0f", ")", "==", "0x0f", ")", "n_regs", "=", "4", ";", "else", "if", "(", "(", "!", "TARGET_H8300SX", "||", "(", "regno", "&", "3", ")", "==", "0", ")", "&&", "(", "(", "saved_regs", ">>", "regno", ")", "&", "0x07", ")", "==", "0x07", ")", "n_regs", "=", "3", ";", "else", "if", "(", "(", "!", "TARGET_H8300SX", "||", "(", "regno", "&", "1", ")", "==", "0", ")", "&&", "(", "(", "saved_regs", ">>", "regno", ")", "&", "0x03", ")", "==", "0x03", ")", "n_regs", "=", "2", ";", "}", "h8300_push_pop", "(", "regno", ",", "n_regs", ",", "false", ",", "false", ")", ";", "}", "}", "h8300_emit_stack_adjustment", "(", "-", "1", ",", "round_frame_size", "(", "get_frame_size", "(", ")", ")", ",", "true", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "round_frame_size", "(", "get_frame_size", "(", ")", ")", "+", "(", "__builtin_popcount", "(", "saved_regs", ")", "*", "UNITS_PER_WORD", ")", "+", "(", "frame_pointer_needed", "?", "UNITS_PER_WORD", ":", "0", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "code", "for", "the", "function", "prologue", "." ]

[ "h8300", "0", "1", "1", "3", "0", "0x0f", "0x0f", "4", "3", "0", "0x07", "0x07", "3", "1", "0", "0x03", "0x03", "2", "1", "0" ]

[]

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

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

[ "AMDGPU", "\"SI Fold Operands\"" ]

[]

[ "<s>", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "override", "{", "return", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "R600" ]

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStBaseOp", "(", "const", "MachineInstr", "*", "MI", ")", "{", "unsigned", "Idx", "=", "isPairedLdSt", "(", "MI", ")", "?", "2", ":", "1", ";", "return", "MI", "->", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "base", "register", "operator", "of", "a", "load/store", "." ]

[ "AArch64", "2", "1" ]

[]

[ "<s>", "static", "void", "mips_get_arg_info", "(", "struct", "mips_arg_info", "*", "info", ",", "const", "CUMULATIVE_ARGS", "*", "cum", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "bool", "doubleword_aligned_p", ";", "unsigned", "int", "num_bytes", ",", "num_words", ",", "max_regs", ";", "num_bytes", "=", "type", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "num_words", "=", "(", "num_bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "switch", "(", "mips_abi", ")", "{", "case", "ABI_EABI", ":", "info", "->", "fpr_p", "=", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "V2SFmode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_FPVALUE", ")", ";", "break", ";", "case", "ABI_32", ":", "case", "ABI_O64", ":", "gcc_assert", "(", "TARGET_PAIRED_SINGLE_FLOAT", "||", "mode", "!=", "V2SFmode", ")", ";", "info", "->", "fpr_p", "=", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<", "2", "&&", "(", "type", "==", "0", "||", "SCALAR_FLOAT_TYPE_P", "(", "type", ")", "||", "VECTOR_FLOAT_TYPE_P", "(", "type", ")", ")", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "V2SFmode", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_FPVALUE", ")", ";", "break", ";", "case", "ABI_N32", ":", "case", "ABI_64", ":", "gcc_assert", "(", "TARGET_PAIRED_SINGLE_FLOAT", "||", "mode", "!=", "V2SFmode", ")", ";", "info", "->", "fpr_p", "=", "(", "named", "&&", "(", "type", "==", "0", "||", "FLOAT_TYPE_P", "(", "type", ")", ")", "&&", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "||", "mode", "==", "V2SFmode", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "UNITS_PER_FPVALUE", ")", ";", "if", "(", "info", "->", "fpr_p", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<", "UNITS_PER_FPVALUE", ")", "{", "if", "(", "cum", "->", "num_gprs", ">=", "MAX_ARGS_IN_REGISTERS", "-", "1", ")", "info", "->", "fpr_p", "=", "false", ";", "else", "num_words", "=", "2", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "doubleword_aligned_p", "=", "(", "mips_function_arg_boundary", "(", "mode", ",", "type", ")", ">", "BITS_PER_WORD", ")", ";", "info", "->", "reg_offset", "=", "(", "mips_abi", "==", "ABI_EABI", "&&", "info", "->", "fpr_p", "?", "cum", "->", "num_fprs", ":", "cum", "->", "num_gprs", ")", ";", "if", "(", "doubleword_aligned_p", ")", "info", "->", "reg_offset", "+=", "info", "->", "reg_offset", "&", "1", ";", "info", "->", "stack_offset", "=", "cum", "->", "stack_words", ";", "if", "(", "doubleword_aligned_p", ")", "info", "->", "stack_offset", "+=", "info", "->", "stack_offset", "&", "1", ";", "max_regs", "=", "MAX_ARGS_IN_REGISTERS", "-", "info", "->", "reg_offset", ";", "info", "->", "reg_words", "=", "MIN", "(", "num_words", ",", "max_regs", ")", ";", "info", "->", "stack_words", "=", "num_words", "-", "info", "->", "reg_words", ";", "}", "</s>" ]

[ "Fill", "INFO", "with", "information", "about", "a", "single", "argument", ".", "CUM", "is", "the", "cumulative", "state", "for", "earlier", "arguments", ".", "MODE", "is", "the", "mode", "of", "this", "argument", "and", "TYPE", "is", "its", "type", "(", "if", "known", ")", ".", "NAMED", "is", "true", "if", "this", "is", "a", "named", "(", "fixed", ")", "argument", "rather", "than", "a", "variable", "one", "." ]

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

[]

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

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

[ "M68k", "M68k" ]

[]

[ "<s>", "TargetPassConfig", "*", "LoongArchTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "LoongArchPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "LoongArch", "LoongArch", "LoongArch" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FPTOSI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_FPTOUI", ":", "return", "legalizeFPTOI", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SHUFFLE_VECTOR", ":", "return", "legalizeShuffleVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "MI", ",", "MRI", ",", "B", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "legalizeFDIV", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_UDIV", ":", "case", "TargetOpcode", "::", "G_UREM", ":", "return", "legalizeUDIV_UREM", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SDIV", ":", "case", "TargetOpcode", "::", "G_SREM", ":", "return", "legalizeSDIV_SREM", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_ATOMIC_CMPXCHG", ":", "return", "legalizeAtomicCmpXChg", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FLOG", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "numbers", "::", "ln2f", ")", ";", "case", "TargetOpcode", "::", "G_FLOG10", ":", "return", "legalizeFlog", "(", "MI", ",", "B", ",", "numbers", "::", "ln2f", "/", "numbers", "::", "ln10f", ")", ";", "case", "TargetOpcode", "::", "G_FEXP", ":", "return", "legalizeFExp", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FPOW", ":", "return", "legalizeFPow", "(", "MI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FFLOOR", ":", "return", "legalizeFFloor", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_BUILD_VECTOR", ":", "return", "legalizeBuildVector", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "SI", "\"expected switch to return\"" ]

[]

[ "<s>", "bool", "SILowerI1Copies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_MOV_I1", ")", "{", "MI", ".", "setDesc", "(", "TII", "->", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ")", ";", "continue", ";", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "COPY", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "||", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "MRI", ".", "getRegClass", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ";", "if", "(", "DstRC", "==", "&", "AMDGPU", "::", "VReg_1RegClass", "&&", "TRI", "->", "getCommonSubClass", "(", "SrcRC", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", ")", "{", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_CNDMASK_B32_e64", ")", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "-", "1", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "if", "(", "TRI", "->", "getCommonSubClass", "(", "DstRC", ",", "&", "AMDGPU", "::", "SGPR_64RegClass", ")", "&&", "SrcRC", "==", "&", "AMDGPU", "::", "VReg_1RegClass", ")", "{", "BuildMI", "(", "MBB", ",", "&", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_CMP_NE_I32_e64", ")", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "0", ")", ".", "addOperand", "(", "MI", ".", "getOperand", "(", "1", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "WebAssemblyTargetMachine", "::", "parseMachineFunctionInfo", "(", "const", "yaml", "::", "MachineFunctionInfo", "&", "MFI", ",", "PerFunctionMIParsingState", "&", "PFS", ",", "SMDiagnostic", "&", "Error", ",", "SMRange", "&", "SourceRange", ")", "const", "{", "const", "auto", "&", "YamlMFI", "=", "static_cast", "<", "const", "yaml", "::", "WebAssemblyFunctionInfo", "&", ">", "(", "MFI", ")", ";", "MachineFunction", "&", "MF", "=", "PFS", ".", "MF", ";", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "initializeBaseYamlFields", "(", "YamlMFI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Parse", "out", "the", "target", "'s", "MachineFunctionInfo", "from", "the", "YAML", "reprsentation", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

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

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

[ "DLX", "DLX" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "}", "else", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_8", ")", "{", "unsigned", "Size", "=", "Fixup", ".", "getKind", "(", ")", "==", "FK_Data_4", "?", "4", ":", "8", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "Size", "-", "i", "-", "1", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "Idx", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "}", "else", "{", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "Value", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "if", "(", "IsLittleEndian", ")", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", "&", "0xFF", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", ">>", "8", ";", "}", "else", "{", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "Value", ">>", "8", ";", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "3", "]", "=", "Value", "&", "0xFF", ";", "}", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "0", "4", "8", "0", "1", "8", "8", "8", "2", "0xFF", "3", "8", "2", "8", "3", "0xFF" ]

[]

[ "<s>", "bool", "arc_expand_movmem", "(", "rtx", "*", "operands", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src", "=", "operands", "[", "1", "]", ";", "rtx", "dst_addr", ",", "src_addr", ";", "HOST_WIDE_INT", "size", ";", "int", "align", "=", "INTVAL", "(", "operands", "[", "3", "]", ")", ";", "unsigned", "n_pieces", ";", "int", "piece", "=", "align", ";", "rtx", "store", "[", "2", "]", ";", "rtx", "tmpx", "[", "2", "]", ";", "int", "i", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "return", "false", ";", "size", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "align", ">=", "4", ")", "n_pieces", "=", "(", "size", "+", "2", ")", "/", "4U", "+", "(", "size", "&", "1", ")", ";", "else", "if", "(", "align", "==", "2", ")", "n_pieces", "=", "(", "size", "+", "1", ")", "/", "2U", ";", "else", "n_pieces", "=", "size", ";", "if", "(", "n_pieces", ">=", "(", "unsigned", "int", ")", "(", "optimize_size", "?", "3", ":", "15", ")", ")", "return", "false", ";", "if", "(", "piece", ">", "4", ")", "piece", "=", "4", ";", "dst_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "src_addr", "=", "force_offsettable", "(", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ",", "size", ",", "0", ")", ";", "store", "[", "0", "]", "=", "store", "[", "1", "]", "=", "NULL_RTX", ";", "tmpx", "[", "0", "]", "=", "tmpx", "[", "1", "]", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "size", ">", "0", ";", "i", "^=", "1", ",", "size", "-=", "piece", ")", "{", "rtx", "tmp", ";", "machine_mode", "mode", ";", "if", "(", "piece", ">", "size", ")", "piece", "=", "size", "&", "-", "size", ";", "mode", "=", "smallest_mode_for_size", "(", "piece", "*", "BITS_PER_UNIT", ",", "MODE_INT", ")", ";", "if", "(", "0", "&&", "tmpx", "[", "i", "]", "&&", "GET_MODE", "(", "tmpx", "[", "i", "]", ")", "==", "mode", ")", "tmp", "=", "tmpx", "[", "i", "]", ";", "else", "tmpx", "[", "i", "]", "=", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "dst_addr", "=", "force_offsettable", "(", "dst_addr", ",", "piece", ",", "1", ")", ";", "src_addr", "=", "force_offsettable", "(", "src_addr", ",", "piece", ",", "1", ")", ";", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "emit_move_insn", "(", "tmp", ",", "change_address", "(", "src", ",", "mode", ",", "src_addr", ")", ")", ";", "store", "[", "i", "]", "=", "gen_move_insn", "(", "change_address", "(", "dst", ",", "mode", ",", "dst_addr", ")", ",", "tmp", ")", ";", "dst_addr", "=", "plus_constant", "(", "Pmode", ",", "dst_addr", ",", "piece", ")", ";", "src_addr", "=", "plus_constant", "(", "Pmode", ",", "src_addr", ",", "piece", ")", ";", "}", "if", "(", "store", "[", "i", "]", ")", "emit_insn", "(", "store", "[", "i", "]", ")", ";", "if", "(", "store", "[", "i", "^", "1", "]", ")", "emit_insn", "(", "store", "[", "i", "^", "1", "]", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Like", "move_by_pieces", ",", "but", "take", "account", "of", "load", "latency", ",", "and", "actual", "offset", "ranges", ".", "Return", "true", "on", "success", "." ]

[ "arc", "0", "1", "3", "2", "2", "2", "2", "4", "2", "4U", "1", "2", "1", "2U", "3", "15", "4", "4", "0", "0", "0", "1", "0", "0", "0", "1", "0", "1", "0", "0", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "bool", "aarch64_integer_truncation_p", "(", "stmt_vec_info", "stmt_info", ")", "{", "gassign", "*", "assign", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "stmt_info", "->", "stmt", ")", ";", "if", "(", "!", "assign", "||", "!", "CONVERT_EXPR_CODE_P", "(", "gimple_assign_rhs_code", "(", "assign", ")", ")", ")", "return", "false", ";", "tree", "lhs_type", "=", "TREE_TYPE", "(", "gimple_assign_lhs", "(", "assign", ")", ")", ";", "tree", "rhs_type", "=", "TREE_TYPE", "(", "gimple_assign_rhs1", "(", "assign", ")", ")", ";", "return", "(", "INTEGRAL_TYPE_P", "(", "lhs_type", ")", "&&", "INTEGRAL_TYPE_P", "(", "rhs_type", ")", "&&", "TYPE_PRECISION", "(", "lhs_type", ")", "<", "TYPE_PRECISION", "(", "rhs_type", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "STMT_INFO", "is", "an", "integer", "truncation", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ")", "const", "{", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIa", ")", "&&", "MIb", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIb", ")", ")", "return", "true", ";", "unsigned", "BasePosA", ",", "OffsetPosA", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIa", ",", "BasePosA", ",", "OffsetPosA", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseA", "=", "MIa", ".", "getOperand", "(", "BasePosA", ")", ";", "Register", "BaseRegA", "=", "BaseA", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubA", "=", "BaseA", ".", "getSubReg", "(", ")", ";", "unsigned", "BasePosB", ",", "OffsetPosB", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIb", ",", "BasePosB", ",", "OffsetPosB", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseB", "=", "MIb", ".", "getOperand", "(", "BasePosB", ")", ";", "Register", "BaseRegB", "=", "BaseB", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubB", "=", "BaseB", ".", "getSubReg", "(", ")", ";", "if", "(", "BaseRegA", "!=", "BaseRegB", "||", "BaseSubA", "!=", "BaseSubB", ")", "return", "false", ";", "unsigned", "SizeA", "=", "getMemAccessSize", "(", "MIa", ")", ";", "unsigned", "SizeB", "=", "getMemAccessSize", "(", "MIb", ")", ";", "const", "MachineOperand", "&", "OffA", "=", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ";", "const", "MachineOperand", "&", "OffB", "=", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ";", "if", "(", "!", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ".", "isImm", "(", ")", "||", "!", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "int", "OffsetA", "=", "isPostIncrement", "(", "MIa", ")", "?", "0", ":", "OffA", ".", "getImm", "(", ")", ";", "int", "OffsetB", "=", "isPostIncrement", "(", "MIb", ")", "?", "0", ":", "OffB", ".", "getImm", "(", ")", ";", "if", "(", "OffsetA", ">", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetA", "-", "(", "int64_t", ")", "OffsetB", ")", ";", "return", "SizeB", "<=", "OffDiff", ";", "}", "if", "(", "OffsetA", "<", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetB", "-", "(", "int64_t", ")", "OffsetA", ")", ";", "return", "SizeA", "<=", "OffDiff", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

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

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "compute_not_to_clear_mask", "(", "tree", "arg_type", ",", "rtx", "arg_rtx", ",", "int", "regno", ",", "uint32_t", "*", "padding_bits_to_clear", ")", "{", "int", "last_used_bit", "=", "0", ";", "unsigned", "HOST_WIDE_INT", "not_to_clear_mask", ";", "if", "(", "RECORD_OR_UNION_TYPE_P", "(", "arg_type", ")", ")", "{", "not_to_clear_mask", "=", "comp_not_to_clear_mask_str_un", "(", "arg_type", ",", "&", "regno", ",", "padding_bits_to_clear", ",", "0", ",", "&", "last_used_bit", ")", ";", "if", "(", "last_used_bit", "!=", "0", ")", "padding_bits_to_clear", "[", "regno", "]", "|=", "(", "(", "uint32_t", ")", "-", "1", ")", "-", "(", "(", "uint32_t", ")", "1", "<<", "last_used_bit", ")", "+", "1", ";", "else", "not_to_clear_mask", "&=", "~", "(", "HOST_WIDE_INT_1U", "<<", "regno", ")", ";", "}", "else", "{", "not_to_clear_mask", "=", "0", ";", "if", "(", "GET_MODE", "(", "arg_rtx", ")", "==", "BLKmode", ")", "{", "int", "i", ",", "arg_regs", ";", "rtx", "reg", ";", "gcc_assert", "(", "TARGET_HARD_FLOAT_ABI", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "arg_rtx", ",", "0", ")", ";", "i", "++", ")", "{", "reg", "=", "XEXP", "(", "XVECEXP", "(", "arg_rtx", ",", "0", ",", "i", ")", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "reg", ")", ")", ";", "not_to_clear_mask", "|=", "HOST_WIDE_INT_1U", "<<", "REGNO", "(", "reg", ")", ";", "arg_regs", "=", "ARM_NUM_REGS", "(", "GET_MODE", "(", "reg", ")", ")", ";", "if", "(", "arg_regs", ">", "1", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", ";", "mask", "=", "HOST_WIDE_INT_1U", "<<", "(", "REGNO", "(", "reg", ")", "+", "arg_regs", ")", ";", "mask", "-=", "HOST_WIDE_INT_1U", "<<", "REGNO", "(", "reg", ")", ";", "not_to_clear_mask", "|=", "mask", ";", "}", "}", "}", "else", "{", "int", "arg_regs", "=", "ARM_NUM_REGS", "(", "GET_MODE", "(", "arg_rtx", ")", ")", ";", "not_to_clear_mask", "|=", "HOST_WIDE_INT_1U", "<<", "REGNO", "(", "arg_rtx", ")", ";", "if", "(", "arg_regs", ">", "1", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", "=", "HOST_WIDE_INT_1U", "<<", "(", "REGNO", "(", "arg_rtx", ")", "+", "arg_regs", ")", ";", "mask", "-=", "HOST_WIDE_INT_1U", "<<", "REGNO", "(", "arg_rtx", ")", ";", "not_to_clear_mask", "|=", "mask", ";", "}", "}", "}", "return", "not_to_clear_mask", ";", "}", "</s>" ]

[ "In", "the", "context", "of", "ARMv8-M", "Security", "Extensions", ",", "this", "function", "is", "used", "for", "both", "'cmse_nonsecure_call", "'", "and", "'cmse_nonsecure_entry", "'", "functions", "to", "compute", "what", "registers", "are", "used", "when", "returning", "or", "passing", "arguments", ",", "which", "is", "then", "returned", "as", "a", "mask", ".", "It", "will", "also", "compute", "a", "mask", "to", "indicate", "padding/unused", "bits", "for", "each", "of", "these", "registers", ",", "and", "passes", "this", "through", "the", "PADDING_BITS_TO_CLEAR", "pointer", ".", "The", "tree", "of", "the", "argument", "type", "is", "passed", "in", "ARG_TYPE", ",", "the", "rtl", "representation", "of", "the", "argument", "is", "passed", "in", "ARG_RTX", "and", "the", "starting", "register", "used", "to", "pass", "this", "argument", "or", "return", "value", "is", "passed", "in", "REGNO", ".", "It", "makes", "use", "of", "'comp_not_to_clear_mask_str_un", "'", "to", "compute", "these", "for", "struct", "and", "union", "types", "." ]

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

[]

[ "<s>", "void", "SparcInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "'%'", "<<", "StringRef", "(", "getRegisterName", "(", "RegNo", ")", ")", ".", "lower", "(", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon Constant Propagation\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Constant Propagation\"" ]

[]

[ "<s>", "bool", "check", "(", "function_checker", "&", "c", ")", "const", "override", "{", "poly_int64", "outer_size", "=", "GET_MODE_SIZE", "(", "c", ".", "arg_mode", "(", "0", ")", ")", ";", "poly_int64", "inner_size", "=", "GET_MODE_SIZE", "(", "c", ".", "ret_mode", "(", ")", ")", ";", "unsigned", "int", "nvecs", "=", "exact_div", "(", "outer_size", ",", "inner_size", ")", ".", "to_constant", "(", ")", ";", "return", "c", ".", "require_immediate", "(", "1", ",", "0", ",", "nvecs", "-", "1", ")", ";", "}", "</s>" ]

[ "Perform", "semantic", "checks", "on", "the", "call", ".", "Return", "true", "if", "the", "call", "is", "valid", ",", "otherwise", "report", "a", "suitable", "error", "." ]

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

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n********** Patmos Function Splitter **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Function: \"", "<<", "MF", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "if", "(", "DisableFunctionSplitter", ")", "return", "false", ";", "unsigned", "max_subfunc_size", "=", "MaxSubfunctionSize", "?", "MaxSubfunctionSize", ":", "STC", ".", "getMethodCacheSize", "(", ")", ";", "max_subfunc_size", "=", "std", "::", "min", "(", "max_subfunc_size", ",", "STC", ".", "getMethodCacheSize", "(", ")", ")", ";", "unsigned", "prefer_subfunc_size", "=", "PreferSubfunctionSize", "?", "PreferSubfunctionSize", ":", "max_subfunc_size", ";", "unsigned", "prefer_scc_size", "=", "PreferSCCSize", "?", "PreferSCCSize", ":", "prefer_subfunc_size", ";", "prefer_subfunc_size", "=", "std", "::", "min", "(", "max_subfunc_size", ",", "prefer_subfunc_size", ")", ";", "if", "(", "prefer_subfunc_size", "<", "64", ")", "{", "report_fatal_error", "(", "\"Subfunction size less than 64 bytes!.\"", ")", ";", "}", "prefer_scc_size", "=", "std", "::", "min", "(", "max_subfunc_size", ",", "prefer_scc_size", ")", ";", "unsigned", "total_size", "=", "0", ";", "bool", "blocks_splitted", "=", "false", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachinePostDominatorTree", "&", "MPDT", "=", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "i", "(", "MF", ".", "begin", "(", ")", ")", ",", "ie", "(", "MF", ".", "end", "(", ")", ")", ";", "i", "!=", "ie", ";", "i", "++", ")", "{", "unsigned", "bb_size", "=", "agraph", "::", "getBBSize", "(", "&", "*", "i", ",", "PTM", ")", ";", "if", "(", "bb_size", "+", "agraph", "::", "getMaxBlockMargin", "(", "PTM", ",", "&", "*", "i", ")", ">", "max_subfunc_size", ")", "{", "bb_size", "=", "agraph", "::", "splitBlock", "(", "&", "*", "i", ",", "max_subfunc_size", ",", "PTM", ",", "MDT", ",", "MPDT", ")", ";", "blocks_splitted", "=", "true", ";", "}", "total_size", "+=", "bb_size", ";", "}", "TotalFunctions", "++", ";", "if", "(", "total_size", ">", "prefer_subfunc_size", ")", "{", "bool", "CollectStats", "=", "!", "StatsFile", ".", "empty", "(", ")", ";", "TimeRecord", "Time", ";", "if", "(", "CollectStats", ")", "Time", "-=", "TimeRecord", "::", "getCurrentTime", "(", "true", ")", ";", "agraph", "G", "(", "&", "MF", ",", "PTM", ",", "MPDT", ",", "prefer_subfunc_size", ",", "prefer_scc_size", ",", "max_subfunc_size", ")", ";", "G", ".", "transformSCCs", "(", ")", ";", "ablocks", "order", ";", "G", ".", "computeRegions", "(", "order", ")", ";", "assert", "(", "order", ".", "size", "(", ")", "==", "MF", ".", "size", "(", ")", ")", ";", "G", ".", "applyRegions", "(", "order", ")", ";", "if", "(", "CollectStats", ")", "{", "Time", "+=", "TimeRecord", "::", "getCurrentTime", "(", "false", ")", ";", "writeStats", "(", "StatsFile", ",", "MF", ",", "G", ",", "order", ",", "total_size", ",", "Time", ")", ";", "}", "SplitFunctions", "++", ";", "blocks_splitted", "=", "true", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n********** Finnishing Patmos Function Splitter **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Function: \"", "<<", "MF", ".", "getFunction", "(", ")", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "LLVM_DEBUG", "(", "MF", ".", "dump", "(", ")", ")", ";", "return", "blocks_splitted", ";", "}", "</s>" ]

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

[ "Patmos", "\"\\n********** Patmos Function Splitter **********\\n\"", "\"********** Function: \"", "\"**********\\n\"", "64", "\"Subfunction size less than 64 bytes!.\"", "0", "\"\\n********** Finnishing Patmos Function Splitter **********\\n\"", "\"********** Function: \"", "\"**********\\n\"" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this\"", ")", ";", "case", "ISD", "::", "BITCAST", ":", "ReplaceBITCASTResults", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "case", "ISD", "::", "VECREDUCE_ADD", ":", "case", "ISD", "::", "VECREDUCE_SMAX", ":", "case", "ISD", "::", "VECREDUCE_SMIN", ":", "case", "ISD", "::", "VECREDUCE_UMAX", ":", "case", "ISD", "::", "VECREDUCE_UMIN", ":", "Results", ".", "push_back", "(", "LowerVECREDUCE", "(", "SDValue", "(", "N", ",", "0", ")", ",", "DAG", ")", ")", ";", "return", ";", "case", "AArch64ISD", "::", "SADDV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "ADD", ",", "AArch64ISD", "::", "SADDV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "UADDV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "ADD", ",", "AArch64ISD", "::", "UADDV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "SMINV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "SMIN", ",", "AArch64ISD", "::", "SMINV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "UMINV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "UMIN", ",", "AArch64ISD", "::", "UMINV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "SMAXV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "SMAX", ",", "AArch64ISD", "::", "SMAXV", ")", ";", "return", ";", "case", "AArch64ISD", "::", "UMAXV", ":", "ReplaceReductionResults", "(", "N", ",", "Results", ",", "DAG", ",", "ISD", "::", "UMAX", ",", "AArch64ISD", "::", "UMAXV", ")", ";", "return", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "case", "ISD", "::", "FP_TO_SINT", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i128", "&&", "\"unexpected illegal conversion\"", ")", ";", "return", ";", "case", "ISD", "::", "ATOMIC_CMP_SWAP", ":", "ReplaceCMP_SWAP_128Results", "(", "N", ",", "Results", ",", "DAG", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Don't know how to custom expand this\"", "ISD::BITCAST", "ISD::VECREDUCE_ADD", "ISD::VECREDUCE_SMAX", "ISD::VECREDUCE_SMIN", "ISD::VECREDUCE_UMAX", "ISD::VECREDUCE_UMIN", "0", "AArch64ISD::SADDV", "ISD::ADD", "AArch64ISD::SADDV", "AArch64ISD::UADDV", "ISD::ADD", "AArch64ISD::UADDV", "AArch64ISD::SMINV", "ISD::SMIN", "AArch64ISD::SMINV", "AArch64ISD::UMINV", "ISD::UMIN", "AArch64ISD::UMINV", "AArch64ISD::SMAXV", "ISD::SMAX", "AArch64ISD::SMAXV", "AArch64ISD::UMAXV", "ISD::UMAX", "AArch64ISD::UMAXV", "ISD::FP_TO_UINT", "ISD::FP_TO_SINT", "0", "MVT::i128", "\"unexpected illegal conversion\"", "ISD::ATOMIC_CMP_SWAP" ]

[]

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

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

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

[]

[ "<s>", "inline", "tree", "function_instance", "::", "vector_type", "(", "unsigned", "int", "i", ")", "const", "{", "return", "acle_vector_types", "[", "0", "]", "[", "type_suffix", "(", "i", ")", ".", "vector_type", "]", ";", "}", "</s>" ]

[ "Return", "the", "vector", "type", "associated", "with", "type", "suffix", "I", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isAsCheapAsAMove", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "RISCV", "::", "FSGNJ_D", ":", "case", "RISCV", "::", "FSGNJ_S", ":", "return", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "case", "RISCV", "::", "ADDI", ":", "case", "RISCV", "::", "ORI", ":", "case", "RISCV", "::", "XORI", ":", "return", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "RISCV", "::", "X0", ")", "||", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", ";", "}", "return", "MI", ".", "isAsCheapAsAMove", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "as", "cheap", "as", "a", "move", "instruction", "." ]

[ "RISCV", "RISCV", "RISCV::FSGNJ_D", "RISCV::FSGNJ_S", "1", "2", "1", "2", "RISCV::ADDI", "RISCV::ORI", "RISCV::XORI", "1", "1", "RISCV::X0", "2", "2", "0" ]

[]

[ "<s>", "SDNode", "*", "MBlazeDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"SystemZ Long Branch\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ Long Branch\"" ]

[]

[ "<s>", "void", "XCoreTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "BSSSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".dp.bss.large\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "DataSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".dp.data.large\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "DataRelROSection", "=", "Ctx", ".", "getELFSection", "(", "\".dp.rodata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "DataRelROSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".dp.rodata.large\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "ReadOnlySectionLarge", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.large\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "MergeableConst4Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst4\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst4", "(", ")", ")", ";", "MergeableConst8Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst8\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst8", "(", ")", ")", ";", "MergeableConst16Section", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.cst16\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getMergeableConst16", "(", ")", ")", ";", "CStringSection", "=", "Ctx", ".", "getELFSection", "(", "\".cp.rodata.string\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_MERGE", "|", "ELF", "::", "SHF_STRINGS", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ",", "SectionKind", "::", "getReadOnlyWithRel", "(", ")", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "\".dp.bss\"", "\".dp.bss.large\"", "\".dp.data\"", "\".dp.data.large\"", "\".dp.rodata\"", "\".dp.rodata.large\"", "\".cp.rodata\"", "\".cp.rodata.large\"", "\".cp.rodata.cst4\"", "\".cp.rodata.cst8\"", "\".cp.rodata.cst16\"", "\".cp.rodata.string\"" ]

[]

[ "<s>", "bool", "IA64TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createIA64BundlingPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "IA64", "IA64", "IA64" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_rev_global", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "poly_uint64", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", "||", "d", "->", "vec_flags", "!=", "VEC_SVE_DATA", ")", "return", "false", ";", "if", "(", "!", "d", "->", "perm", ".", "series_p", "(", "0", ",", "1", ",", "nelt", "-", "1", ",", "-", "1", ")", ")", "return", "false", ";", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "rtx", "src", "=", "gen_rtx_UNSPEC", "(", "d", "->", "vmode", ",", "gen_rtvec", "(", "1", ",", "d", "->", "op0", ")", ",", "UNSPEC_REV", ")", ";", "emit_set_insn", "(", "d", "->", "target", ",", "src", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "REV", "insn", ",", "which", "reverses", "elements", "within", "a", "full", "vector", "." ]

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

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "reduceLoopCount", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineInstr", "*", "IndVar", ",", "MachineInstr", "&", "Cmp", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "PrevInsts", ",", "unsigned", "Iter", ",", "unsigned", "MaxIter", ")", "const", "{", "assert", "(", "(", "!", "IndVar", ")", "&&", "isEndLoopN", "(", "Cmp", ".", "getOpcode", "(", ")", ")", "&&", "\"Expecting a hardware loop\"", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "Cmp", ".", "getDebugLoc", "(", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "VisitedBBs", ";", "MachineInstr", "*", "Loop", "=", "findLoopInstr", "(", "&", "MBB", ",", "Cmp", ".", "getOpcode", "(", ")", ",", "Cmp", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ",", "VisitedBBs", ")", ";", "if", "(", "!", "Loop", ")", "return", "0", ";", "if", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0i", "||", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop1i", ")", "{", "int64_t", "Offset", "=", "Loop", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", "<=", "1", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "else", "Loop", "->", "getOperand", "(", "1", ")", ".", "setImm", "(", "Offset", "-", "1", ")", ";", "return", "Offset", "-", "1", ";", "}", "assert", "(", "Loop", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "J2_loop0r", "&&", "\"Unexpected instruction\"", ")", ";", "unsigned", "LoopCount", "=", "Loop", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "LoopEnd", "=", "createVR", "(", "MF", ",", "MVT", "::", "i1", ")", ";", "MachineInstr", "*", "NewCmp", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "C2_cmpgtui", ")", ",", "LoopEnd", ")", ".", "addReg", "(", "LoopCount", ")", ".", "addImm", "(", "1", ")", ";", "unsigned", "NewLoopCount", "=", "createVR", "(", "MF", ",", "MVT", "::", "i32", ")", ";", "MachineInstr", "*", "NewAdd", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "A2_addi", ")", ",", "NewLoopCount", ")", ".", "addReg", "(", "LoopCount", ")", ".", "addImm", "(", "-", "1", ")", ";", "const", "HexagonRegisterInfo", "&", "HRI", "=", "*", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "PrevInsts", ".", "begin", "(", ")", ",", "E", "=", "PrevInsts", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "substituteRegister", "(", "LoopCount", ",", "NewLoopCount", ",", "0", ",", "HRI", ")", ";", "PrevInsts", ".", "clear", "(", ")", ";", "PrevInsts", ".", "push_back", "(", "NewCmp", ")", ";", "PrevInsts", ".", "push_back", "(", "NewAdd", ")", ";", "if", "(", "Iter", "==", "MaxIter", ")", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Hexagon", "::", "J2_loop0r", ")", ")", ".", "addMBB", "(", "Loop", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ".", "addReg", "(", "NewLoopCount", ")", ";", "if", "(", "Iter", "==", "0", ")", "Loop", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "Hexagon", "::", "J2_jumpf", ")", ")", ";", "Cond", ".", "push_back", "(", "NewCmp", "->", "getOperand", "(", "0", ")", ")", ";", "return", "NewLoopCount", ";", "}", "</s>" ]

[ "Generate", "code", "to", "reduce", "the", "loop", "iteration", "by", "one", "and", "check", "if", "the", "loop", "is", "finished", "." ]

[ "Hexagon", "Hexagon", "\"Expecting a hardware loop\"", "8", "0", "0", "Hexagon::J2_loop0i", "Hexagon::J2_loop1i", "1", "1", "1", "1", "1", "Hexagon::J2_loop0r", "\"Unexpected instruction\"", "1", "MVT::i1", "Hexagon::C2_cmpgtui", "1", "MVT::i32", "Hexagon::A2_addi", "1", "Hexagon", "0", "Hexagon::J2_loop0r", "0", "0", "Hexagon::J2_jumpf", "0" ]

[]

[ "<s>", "rtx", "ix86_expand_adjust_ufix_to_sfix_si", "(", "rtx", "val", ",", "rtx", "*", "xorp", ")", "{", "REAL_VALUE_TYPE", "TWO31r", ";", "rtx", "two31r", ",", "tmp", "[", "4", "]", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "val", ")", ";", "machine_mode", "scalarmode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "machine_mode", "intmode", "=", "GET_MODE_SIZE", "(", "mode", ")", "==", "32", "?", "V8SImode", ":", "V4SImode", ";", "rtx", "(", "*", "cmp", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "tmp", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode", ")", ";", "real_ldexp", "(", "&", "TWO31r", ",", "&", "dconst1", ",", "31", ")", ";", "two31r", "=", "const_double_from_real_value", "(", "TWO31r", ",", "scalarmode", ")", ";", "two31r", "=", "ix86_build_const_vector", "(", "mode", ",", "1", ",", "two31r", ")", ";", "two31r", "=", "force_reg", "(", "mode", ",", "two31r", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V8SFmode", ":", "cmp", "=", "gen_avx_maskcmpv8sf3", ";", "break", ";", "case", "E_V4SFmode", ":", "cmp", "=", "gen_sse_maskcmpv4sf3", ";", "break", ";", "case", "E_V4DFmode", ":", "cmp", "=", "gen_avx_maskcmpv4df3", ";", "break", ";", "case", "E_V2DFmode", ":", "cmp", "=", "gen_sse2_maskcmpv2df3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "tmp", "[", "3", "]", "=", "gen_rtx_LE", "(", "mode", ",", "two31r", ",", "val", ")", ";", "emit_insn", "(", "cmp", "(", "tmp", "[", "0", "]", ",", "two31r", ",", "val", ",", "tmp", "[", "3", "]", ")", ")", ";", "tmp", "[", "1", "]", "=", "expand_simple_binop", "(", "mode", ",", "AND", ",", "tmp", "[", "0", "]", ",", "two31r", ",", "tmp", "[", "1", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "intmode", "==", "V4SImode", "||", "TARGET_AVX2", ")", "*", "xorp", "=", "expand_simple_binop", "(", "intmode", ",", "ASHIFT", ",", "gen_lowpart", "(", "intmode", ",", "tmp", "[", "0", "]", ")", ",", "GEN_INT", "(", "31", ")", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "else", "{", "rtx", "two31", "=", "GEN_INT", "(", "HOST_WIDE_INT_1U", "<<", "31", ")", ";", "two31", "=", "ix86_build_const_vector", "(", "intmode", ",", "1", ",", "two31", ")", ";", "*", "xorp", "=", "expand_simple_binop", "(", "intmode", ",", "AND", ",", "gen_lowpart", "(", "intmode", ",", "tmp", "[", "0", "]", ")", ",", "two31", ",", "NULL_RTX", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "return", "expand_simple_binop", "(", "mode", ",", "MINUS", ",", "val", ",", "tmp", "[", "1", "]", ",", "tmp", "[", "2", "]", ",", "0", ",", "OPTAB_DIRECT", ")", ";", "}", "</s>" ]

[ "Adjust", "a", "V", "*", "SFmode/V", "*", "DFmode", "value", "VAL", "so", "that", "*", "sfix_trunc", "*", "resp", ".", "fix_trunc", "*", "pattern", "can", "be", "used", "on", "it", "instead", "of", "fixuns_trunc", "*", ".", "This", "is", "done", "by", "doing", "just", "signed", "conversion", "if", "<", "0x1p31", ",", "and", "otherwise", "by", "subtracting", "0x1p31", "first", "and", "xoring", "in", "0x80000000", "from", "*", "XORP", "afterwards", "." ]

[ "i386", "4", "32", "0", "3", "31", "1", "3", "0", "3", "1", "0", "1", "0", "0", "31", "0", "31", "1", "0", "0", "1", "2", "0" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "PatmosAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "Patmos", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"FK_Patmos_BO_7\"", ",", "25", ",", "7", ",", "0", "}", ",", "{", "\"FK_Patmos_SO_7\"", ",", "25", ",", "7", ",", "0", "}", ",", "{", "\"FK_Patmos_WO_7\"", ",", "25", ",", "7", ",", "0", "}", ",", "{", "\"FK_Patmos_abs_ALUi\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"FK_Patmos_abs_CFLi\"", ",", "10", ",", "22", ",", "0", "}", ",", "{", "\"FK_Patmos_abs_ALUl\"", ",", "32", ",", "32", ",", "0", "}", ",", "{", "\"FK_Patmos_stc\"", ",", "14", ",", "18", ",", "0", "}", ",", "{", "\"FK_Patmos_PCrel\"", ",", "10", ",", "22", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "Patmos", "Patmos", "Patmos::NumTargetFixupKinds", "\"FK_Patmos_BO_7\"", "25", "7", "0", "\"FK_Patmos_SO_7\"", "25", "7", "0", "\"FK_Patmos_WO_7\"", "25", "7", "0", "\"FK_Patmos_abs_ALUi\"", "20", "12", "0", "\"FK_Patmos_abs_CFLi\"", "10", "22", "0", "\"FK_Patmos_abs_ALUl\"", "32", "32", "0", "\"FK_Patmos_stc\"", "14", "18", "0", "\"FK_Patmos_PCrel\"", "10", "22", "\"Invalid kind!\"" ]

[]

[ "<s>", "SDNode", "*", "Cpu0DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "MF", "->", "getInfo", "<", "Cpu0MachineFunctionInfo", ">", "(", ")", "->", "getGlobalBaseReg", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "getTargetLowering", "(", ")", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_parm_start", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "unsigned", "int", "nwords", ")", "{", "unsigned", "int", "align", ";", "unsigned", "int", "parm_offset", ";", "align", "=", "function_arg_boundary", "(", "mode", ",", "type", ")", "/", "PARM_BOUNDARY", "-", "1", ";", "parm_offset", "=", "DEFAULT_ABI", "==", "ABI_V4", "?", "2", ":", "6", ";", "return", "nwords", "+", "(", "-", "(", "parm_offset", "+", "nwords", ")", "&", "align", ")", ";", "}", "</s>" ]

[ "For", "a", "function", "parm", "of", "MODE", "and", "TYPE", ",", "return", "the", "starting", "word", "in", "the", "parameter", "area", ".", "NWORDS", "of", "the", "parameter", "area", "are", "already", "used", "." ]

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

[]

[ "<s>", "enum", "aarch64_symbol_type", "aarch64_classify_symbol", "(", "rtx", "x", ",", "rtx", "offset", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "{", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_LARGE", ":", "return", "SYMBOL_FORCE_TO_MEM", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "case", "AARCH64_CMODEL_TINY", ":", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "case", "AARCH64_CMODEL_SMALL", ":", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "aarch64_tls_symbol_p", "(", "x", ")", ")", "return", "aarch64_classify_tls_symbol", "(", "x", ")", ";", "switch", "(", "aarch64_cmodel", ")", "{", "case", "AARCH64_CMODEL_TINY", ":", "if", "(", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "&&", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "||", "INTVAL", "(", "offset", ")", "<", "-", "1048575", "||", "INTVAL", "(", "offset", ")", ">", "1048575", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL", ":", "if", "(", "(", "SYMBOL_REF_WEAK", "(", "x", ")", "&&", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "offset", ")", ",", "HOST_WIDE_INT_C", "(", "-", "4294967263", ")", ",", "HOST_WIDE_INT_C", "(", "4294967264", ")", ")", ")", "return", "SYMBOL_FORCE_TO_MEM", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_TINY_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "SYMBOL_TINY_GOT", ";", "return", "SYMBOL_TINY_ABSOLUTE", ";", "case", "AARCH64_CMODEL_SMALL_SPIC", ":", "case", "AARCH64_CMODEL_SMALL_PIC", ":", "if", "(", "!", "aarch64_symbol_binds_local_p", "(", "x", ")", ")", "return", "(", "aarch64_cmodel", "==", "AARCH64_CMODEL_SMALL_SPIC", "?", "SYMBOL_SMALL_GOT_28K", ":", "SYMBOL_SMALL_GOT_4G", ")", ";", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "case", "AARCH64_CMODEL_LARGE", ":", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "x", ")", ")", "return", "SYMBOL_SMALL_ABSOLUTE", ";", "else", "return", "SYMBOL_FORCE_TO_MEM", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "return", "SYMBOL_FORCE_TO_MEM", ";", "}", "</s>" ]

[ "Return", "the", "method", "that", "should", "be", "used", "to", "access", "SYMBOL_REF", "or", "LABEL_REF", "X", "." ]

[ "aarch64", "1048575", "1048575", "4294967263", "4294967264" ]

[]

[ "<s>", "virtual", "const", "MCObjectFormat", "&", "getObjectFormat", "(", ")", "const", "{", "return", "Format", ";", "}", "</s>" ]

[ "Get", "the", "object", "format", "for", "this", "triple", "." ]

[ "PowerPC" ]

[]

[ "<s>", "BitVector", "ARMBaseRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "const", "ARMFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "SP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "PC", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "FPSCR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "APSR_NZCV", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "getFramePointerReg", "(", "STI", ")", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "BasePtr", ")", ";", "if", "(", "STI", ".", "isR9Reserved", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "R9", ")", ";", "if", "(", "!", "STI", ".", "hasD32", "(", ")", ")", "{", "static_assert", "(", "ARM", "::", "D31", "==", "ARM", "::", "D16", "+", "15", ",", "\"Register list not consecutive!\"", ")", ";", "for", "(", "unsigned", "R", "=", "0", ";", "R", "<", "16", ";", "++", "R", ")", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "D16", "+", "R", ")", ";", "}", "const", "TargetRegisterClass", "&", "RC", "=", "ARM", "::", "GPRPairRegClass", ";", "for", "(", "unsigned", "Reg", ":", "RC", ")", "for", "(", "MCSubRegIterator", "SI", "(", "Reg", ",", "this", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "Reserved", ".", "test", "(", "*", "SI", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "markSuperRegs", "(", "Reserved", ",", "ARM", "::", "ZR", ")", ";", "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", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM::SP", "ARM::PC", "ARM::FPSCR", "ARM::APSR_NZCV", "ARM::R9", "ARM::D31", "ARM::D16", "15", "\"Register list not consecutive!\"", "0", "16", "ARM::D16", "ARM::GPRPairRegClass", "ARM::ZR" ]

[]

[ "<s>", "static", "void", "vax_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "}", "</s>" ]

[ "When", "debugging", "with", "stabs", ",", "we", "want", "to", "output", "an", "extra", "dummy", "label", "so", "that", "gas", "can", "distinguish", "between", "D_float", "and", "G_float", "prior", "to", "processing", "the", ".stabs", "directive", "identifying", "type", "double", "." ]

[ "vax" ]

[]

[ "<s>", "char", "*", "iq2000_output_conditional_branch", "(", "rtx_insn", "*", "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>", "bool", "aarch64_mov128_immediate", "(", "rtx", "imm", ")", "{", "if", "(", "GET_CODE", "(", "imm", ")", "==", "CONST_INT", ")", "return", "true", ";", "gcc_assert", "(", "CONST_WIDE_INT_NUNITS", "(", "imm", ")", "==", "2", ")", ";", "rtx", "lo", "=", "GEN_INT", "(", "CONST_WIDE_INT_ELT", "(", "imm", ",", "0", ")", ")", ";", "rtx", "hi", "=", "GEN_INT", "(", "CONST_WIDE_INT_ELT", "(", "imm", ",", "1", ")", ")", ";", "return", "aarch64_internal_mov_immediate", "(", "NULL_RTX", ",", "lo", ",", "false", ",", "DImode", ")", "+", "aarch64_internal_mov_immediate", "(", "NULL_RTX", ",", "hi", ",", "false", ",", "DImode", ")", "<=", "4", ";", "}", "</s>" ]

[ "Return", "whether", "imm", "is", "a", "128-bit", "immediate", "which", "is", "simple", "enough", "to", "expand", "inline", "." ]

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

[]

[ "<s>", "void", "TL45InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "TL45", "::", "GRRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TL45", "::", "LW", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45::GRRegsRegClass", "TL45::LW", "\"Can't load this register from stack slot\"", "0" ]

[]

[ "<s>", "void", "HexagonRegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKDOWN", ")", "{", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "ADJCALLSTACKUP", ")", "{", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::ADJCALLSTACKDOWN", "Hexagon::ADJCALLSTACKUP", "\"Cannot handle this call frame pseudo instruction\"" ]

[]