Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "savePacket", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "savePacket", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "if", "(", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "savePacket", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]

[ "Keep", "track", "of", "available", "resources", "." ]

[ "Hexagon", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"" ]

[]

[ "<s>", "MCDisassembler", "::", "DecodeStatus", "X86GenericDisassembler", "::", "getInstruction", "(", "MCInst", "&", "instr", ",", "uint64_t", "&", "size", ",", "const", "MemoryObject", "&", "region", ",", "uint64_t", "address", ",", "raw_ostream", "&", "vStream", ",", "raw_ostream", "&", "cStream", ")", "const", "{", "CommentStream", "=", "&", "cStream", ";", "InternalInstruction", "internalInstr", ";", "dlog_t", "loggerFn", "=", "logger", ";", "if", "(", "&", "vStream", "==", "&", "nulls", "(", ")", ")", "loggerFn", "=", "nullptr", ";", "int", "ret", "=", "decodeInstruction", "(", "&", "internalInstr", ",", "regionReader", ",", "(", "const", "void", "*", ")", "&", "region", ",", "loggerFn", ",", "(", "void", "*", ")", "&", "vStream", ",", "(", "const", "void", "*", ")", "MII", ".", "get", "(", ")", ",", "address", ",", "fMode", ")", ";", "if", "(", "ret", ")", "{", "size", "=", "internalInstr", ".", "readerCursor", "-", "address", ";", "return", "Fail", ";", "}", "else", "{", "size", "=", "internalInstr", ".", "length", ";", "return", "(", "!", "translateInstruction", "(", "instr", ",", "internalInstr", ",", "this", ")", ")", "?", "Success", ":", "Fail", ";", "}", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "Module", "::", "const_global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "emitGlobal", "(", "I", ")", ";", "}", "DW", "->", "EndModule", "(", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "AMDGPUIntrinsicInfo", "::", "isOverloaded", "(", "unsigned", "id", ")", "const", "{", "}", "</s>" ]

[ "Returns", "true", "if", "the", "intrinsic", "can", "be", "overloaded", "." ]

[ "R600" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "!", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "return", "ARMBaseInstrInfo", "::", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ")", ";", "bool", "tDest", "=", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "tSrc", "=", "ARM", "::", "tGPRRegClass", ".", "contains", "(", "SrcReg", ")", ";", "unsigned", "Opc", "=", "ARM", "::", "tMOVgpr2gpr", ";", "if", "(", "tDest", "&&", "tSrc", ")", "Opc", "=", "ARM", "::", "tMOVr", ";", "else", "if", "(", "tSrc", ")", "Opc", "=", "ARM", "::", "tMOVtgpr2gpr", ";", "else", "if", "(", "tDest", ")", "Opc", "=", "ARM", "::", "tMOVgpr2tgpr", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM", "ARM::tGPRRegClass", "ARM::tGPRRegClass", "ARM::tMOVgpr2gpr", "ARM::tMOVr", "ARM::tMOVtgpr2gpr", "ARM::tMOVgpr2tgpr" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LoopInfoWrapperPass", ">", "(", ")", ";", "AU", ".", "addRequiredID", "(", "LoopSimplifyID", ")", ";", "AU", ".", "addRequiredID", "(", "LCSSAID", ")", ";", "AU", ".", "addPreservedID", "(", "LCSSAID", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "rs6000_expand_split_stack_prologue", "(", "void", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "unsigned", "HOST_WIDE_INT", "allocate", ";", "long", "alloc_hi", ",", "alloc_lo", ";", "rtx", "r0", ",", "r1", ",", "r12", ",", "lr", ",", "ok_label", ",", "compare", ",", "jump", ",", "call_fusage", ";", "rtx_insn", "*", "insn", ";", "gcc_assert", "(", "flag_split_stack", "&&", "reload_completed", ")", ";", "if", "(", "!", "info", "->", "push_p", ")", "return", ";", "if", "(", "global_regs", "[", "29", "]", ")", "{", "error", "(", "\"-fsplit-stack uses register r29\"", ")", ";", "inform", "(", "DECL_SOURCE_LOCATION", "(", "global_regs_decl", "[", "29", "]", ")", ",", "\"conflicts with %qD\"", ",", "global_regs_decl", "[", "29", "]", ")", ";", "}", "allocate", "=", "info", "->", "total_size", ";", "if", "(", "allocate", ">", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "31", ")", "{", "sorry", "(", "\"Stack frame larger than 2G is not supported for -fsplit-stack\"", ")", ";", "return", ";", "}", "if", "(", "morestack_ref", "==", "NULL_RTX", ")", "{", "morestack_ref", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__morestack\"", ")", ";", "SYMBOL_REF_FLAGS", "(", "morestack_ref", ")", "|=", "(", "SYMBOL_FLAG_LOCAL", "|", "SYMBOL_FLAG_FUNCTION", ")", ";", "}", "r0", "=", "gen_rtx_REG", "(", "Pmode", ",", "0", ")", ";", "r1", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "r12", "=", "gen_rtx_REG", "(", "Pmode", ",", "12", ")", ";", "emit_insn", "(", "gen_load_split_stack_limit", "(", "r0", ")", ")", ";", "alloc_hi", "=", "(", "-", "allocate", "+", "0x8000", ")", "&", "~", "0xffffL", ";", "alloc_lo", "=", "-", "allocate", "-", "alloc_hi", ";", "if", "(", "alloc_hi", "!=", "0", ")", "{", "emit_insn", "(", "gen_add3_const", "(", "r12", ",", "r1", ",", "alloc_hi", ")", ")", ";", "if", "(", "alloc_lo", "!=", "0", ")", "emit_insn", "(", "gen_add3_const", "(", "r12", ",", "r12", ",", "alloc_lo", ")", ")", ";", "else", "emit_insn", "(", "gen_nop", "(", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_add3_const", "(", "r12", ",", "r1", ",", "alloc_lo", ")", ")", ";", "emit_insn", "(", "gen_nop", "(", ")", ")", ";", "}", "compare", "=", "gen_rtx_REG", "(", "CCUNSmode", ",", "CR7_REGNO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "compare", ",", "gen_rtx_COMPARE", "(", "CCUNSmode", ",", "r12", ",", "r0", ")", ")", ")", ";", "ok_label", "=", "gen_label_rtx", "(", ")", ";", "jump", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_GEU", "(", "VOIDmode", ",", "compare", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "ok_label", ")", ",", "pc_rtx", ")", ";", "jump", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "jump", ")", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "ok_label", ";", "add_int_reg_note", "(", "jump", ",", "REG_BR_PROB", ",", "REG_BR_PROB_BASE", "-", "REG_BR_PROB_BASE", "/", "100", ")", ";", "lr", "=", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ";", "insn", "=", "emit_move_insn", "(", "r0", ",", "lr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_insn", "(", "gen_frame_store", "(", "r0", ",", "r1", ",", "info", "->", "lr_save_offset", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "emit_call_insn", "(", "gen_call", "(", "gen_rtx_MEM", "(", "SImode", ",", "morestack_ref", ")", ",", "const0_rtx", ",", "const0_rtx", ")", ")", ";", "call_fusage", "=", "NULL_RTX", ";", "use_reg", "(", "&", "call_fusage", ",", "r12", ")", ";", "add_function_usage_to", "(", "insn", ",", "call_fusage", ")", ";", "emit_insn", "(", "gen_frame_load", "(", "r0", ",", "r1", ",", "info", "->", "lr_save_offset", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "lr", ",", "r0", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "lr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "emit_insn", "(", "gen_split_stack_return", "(", ")", ")", ";", "emit_label", "(", "ok_label", ")", ";", "LABEL_NUSES", "(", "ok_label", ")", "=", "1", ";", "}", "</s>" ]

[ "Emit", "-fsplit-stack", "prologue", ",", "which", "goes", "before", "the", "regular", "function", "prologue", "(", "at", "local", "entry", "point", "in", "the", "case", "of", "ELFv2", ")", "." ]

[ "rs6000", "29", "\"-fsplit-stack uses register r29\"", "29", "\"conflicts with %qD\"", "29", "1", "31", "\"Stack frame larger than 2G is not supported for -fsplit-stack\"", "\"__morestack\"", "0", "12", "0x8000", "0xffffL", "0", "0", "100", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "unsigned", "int", "parse_count", "(", "const", "function_instance", "&", "instance", ",", "const", "char", "*", "&", "format", ")", "{", "if", "(", "format", "[", "0", "]", "==", "'*'", "&&", "format", "[", "1", "]", "==", "'q'", ")", "{", "format", "+=", "2", ";", "return", "instance", ".", "elements_per_vq", "(", "0", ")", ";", "}", "if", "(", "format", "[", "0", "]", "==", "'*'", "&&", "format", "[", "1", "]", "==", "'t'", ")", "{", "format", "+=", "2", ";", "return", "instance", ".", "vectors_per_tuple", "(", ")", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Read", "and", "move", "past", "any", "argument", "count", "at", "FORMAT", "for", "the", "function", "signature", "of", "INSTANCE", ".", "The", "counts", "are", ":", "*", "q", ":", "one", "argument", "per", "element", "in", "a", "128-bit", "quadword", "(", "as", "for", "svdupq", ")", "*", "t", ":", "one", "argument", "per", "vector", "in", "a", "tuple", "(", "as", "for", "svcreate", ")", "Otherwise", "the", "count", "is", "1", "." ]

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

[]

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

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

[ "BPF" ]

[]

[ "<s>", "unsigned", "PPCFastISel", "::", "fastEmit_i", "(", "MVT", "Ty", ",", "MVT", "VT", ",", "unsigned", "Opc", ",", "uint64_t", "Imm", ")", "{", "if", "(", "Opc", "!=", "ISD", "::", "Constant", ")", "return", "0", ";", "if", "(", "VT", "==", "MVT", "::", "i1", "&&", "Subtarget", "->", "useCRBits", "(", ")", ")", "{", "Register", "ImmReg", "=", "createResultReg", "(", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Imm", "==", "0", "?", "PPC", "::", "CRUNSET", ":", "PPC", "::", "CRSET", ")", ",", "ImmReg", ")", ";", "return", "ImmReg", ";", "}", "if", "(", "VT", "!=", "MVT", "::", "i64", "&&", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", "&&", "VT", "!=", "MVT", "::", "i1", ")", "return", "0", ";", "const", "TargetRegisterClass", "*", "RC", "=", "(", "(", "VT", "==", "MVT", "::", "i64", ")", "?", "&", "PPC", "::", "G8RCRegClass", ":", "&", "PPC", "::", "GPRCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i64", ")", "return", "PPCMaterialize64BitInt", "(", "Imm", ",", "RC", ")", ";", "else", "return", "PPCMaterialize32BitInt", "(", "Imm", ",", "RC", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "to", "request", "that", "an", "instruction", "with", "the", "given", "type", ",", "opcode", ",", "and", "immediate", "operand", "be", "emitted", "." ]

[ "PowerPC", "PPC", "ISD::Constant", "0", "MVT::i1", "PPC::CRBITRCRegClass", "0", "PPC::CRUNSET", "PPC::CRSET", "MVT::i64", "MVT::i32", "MVT::i16", "MVT::i8", "MVT::i1", "0", "MVT::i64", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "MVT::i64", "PPC", "PPC" ]

[]

[ "<s>", "virtual", "const", "SPUFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "CellSPU", "SPU" ]

[]

[ "<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 %qs option\"", ",", "\"-mno-pointers-to-nested-functions\"", ")", ";", "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", "." ]

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

[]

[ "<s>", "static", "int", "msp430_shift_costs", "(", "rtx", "src", ",", "rtx", "dst", ",", "bool", "speed", ",", "rtx", "outer_rtx", ")", "{", "int", "amt", ";", "enum", "rtx_code", "src_code", "=", "GET_CODE", "(", "src", ")", ";", "enum", "rtx_code", "dst_code", "=", "GET_CODE", "(", "dst", ")", ";", "const", "struct", "single_op_cost", "*", "cost_p", ";", "cost_p", "=", "(", "speed", "?", "&", "cycle_cost_single_op", ":", "&", "size_cost_single_op", ")", ";", "if", "(", "src_code", "!=", "CONST_INT", ")", "return", "2", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ";", "if", "(", "use_helper_for_const_shift", "(", "GET_MODE", "(", "outer_rtx", ")", ",", "amt", "=", "INTVAL", "(", "src", ")", ")", ")", "{", "return", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ";", "}", "if", "(", "!", "msp430x", ")", "{", "switch", "(", "dst_code", ")", "{", "case", "REG", ":", "case", "CONST_INT", ":", "return", "amt", "*", "cost_p", "->", "reg", ";", "case", "MEM", ":", "if", "(", "msp430_is_mem_indirect", "(", "dst", ")", ")", "return", "amt", "*", "cost_p", "->", "ind", ";", "else", "return", "amt", "*", "cost_p", "->", "mem", ";", "default", ":", "return", "amt", "*", "cost_p", "->", "mem", ";", "}", "}", "return", "(", "amt", "<=", "4", "?", "(", "speed", "?", "amt", ":", "1", ")", ":", "(", "speed", "?", "amt", "+", "1", ":", "2", ")", "+", "(", "dst_code", "==", "REG", "?", "0", ":", "msp430_costs", "(", "dst", ",", "gen_rtx_REG", "(", "HImode", ",", "10", ")", ",", "speed", ",", "outer_rtx", ")", ")", ")", ";", "}", "</s>" ]

[ "Given", "source", "operand", "SRC", "and", "destination", "operand", "DST", "from", "the", "shift", "or", "rotate", "RTX", "OUTER_RTX", ",", "return", "the", "cost", "of", "performing", "that", "shift", ",", "assuming", "optimization", "for", "speed", "when", "SPEED", "is", "true", "." ]

[ "msp430", "2", "4", "1", "1", "2", "0", "10" ]

[]

[ "<s>", "MSP430Subtarget", "&", "MSP430Subtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "StringRef", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"msp430\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "CPUName", ",", "FS", ")", ";", "if", "(", "HWMultModeOption", "!=", "NoHWMult", ")", "HWMultMode", "=", "HWMultModeOption", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "\"msp430\"" ]

[]

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

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

[ "AArch64" ]

[]

[ "<s>", "void", "R600TTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ",", "OptimizationRemarkEmitter", "*", "ORE", ")", "{", "CommonTTI", ".", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ",", "ORE", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600" ]

[]

[ "<s>", "StringRef", "CAHPMCExpr", "::", "getVariantKindName", "(", "VariantKind", "Kind", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid ELF symbol kind\"", ")", ";", "case", "VK_CAHP_LO", ":", "return", "\"lo\"", ";", "case", "VK_CAHP_HI", ":", "return", "\"hi\"", ";", "}", "}", "</s>" ]

[ "Convert", "the", "variant", "kind", "into", "an", "ELF-appropriate", "modifier", "(", "e.g", "." ]

[ "CAHP", "CAHP", "\"Invalid ELF symbol kind\"", "CAHP", "\"lo\"", "CAHP", "\"hi\"" ]

[]

[ "<s>", "bool", "M68kFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M68kRegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "const", "auto", "&", "Info", ":", "CSI", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "Info", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "Info", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "M68k", "::", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M68k", "::", "MOVM32pm", ")", ")", ",", "FI", ")", ".", "addImm", "(", "Mask", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "const", "auto", "&", "Info", ":", "CSI", ")", "{", "unsigned", "Reg", "=", "Info", ".", "getReg", "(", ")", ";", "bool", "IsLiveIn", "=", "RI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "IsLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "I", ".", "addReg", "(", "Reg", ",", "IsLiveIn", "?", "RegState", "::", "Implicit", ":", "RegState", "::", "ImplicitKill", ")", ";", "M68k", "::", "addMemOperand", "(", "I", ",", "Info", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "0", "0", "1", "M68k::addFrameReference", "M68k::MOVM32pm", "M68k::addMemOperand", "0" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCFrameLowering", "*", "PPCFI", "=", "static_cast", "<", "const", "PPCFrameLowering", "*", ">", "(", "Subtarget", ".", "getFrameLowering", "(", ")", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "ZERO8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "FP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "BP", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "BP8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "CTR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "LR8", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "RM", ")", ";", "if", "(", "!", "Subtarget", ".", "isDarwinABI", "(", ")", "||", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R2", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "{", "Reserved", ".", "set", "(", "PPC", "::", "R13", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X1", ")", ";", "Reserved", ".", "set", "(", "PPC", "::", "X13", ")", ";", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X31", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X30", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "FuncInfo", "->", "usesTOCBasePtr", "(", ")", "||", "MF", ".", "hasInlineAsm", "(", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "X2", ")", ";", "else", "Reserved", ".", "reset", "(", "PPC", "::", "R2", ")", ";", "}", "}", "if", "(", "PPCFI", "->", "needsFP", "(", "MF", ")", ")", "Reserved", ".", "set", "(", "PPC", "::", "R31", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Reserved", ".", "set", "(", "PPC", "::", "R29", ")", ";", "else", "Reserved", ".", "set", "(", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Reserved", ".", "set", "(", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "Reserved", ".", "set", "(", "*", "I", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::ZERO8", "PPC::FP", "PPC::FP8", "PPC::BP", "PPC::BP8", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC::R2", "PPC::R13", "PPC", "PPC::R13", "PPC::X1", "PPC::X13", "PPC", "PPC::X31", "PPC::X30", "PPC", "PPC", "PPC::X2", "PPC::R2", "PPC", "PPC::R31", "PPC", "PPC::R29", "PPC::R30", "PPC", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "bool", "PadShortFunc", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "AttributeSet", "&", "FnAttrs", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ";", "if", "(", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", "||", "FnAttrs", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "MinSize", ")", ")", "{", "return", "false", ";", "}", "TM", "=", "&", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "!", "TM", "->", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "padShortFunctions", "(", ")", ")", "return", "false", ";", "TII", "=", "TM", "->", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "ReturnBBs", ".", "clear", "(", ")", ";", "VisitedBBs", ".", "clear", "(", ")", ";", "findReturns", "(", "MF", ".", "begin", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "MachineBasicBlock", "*", "MBB", ";", "unsigned", "int", "Cycles", "=", "0", ";", "for", "(", "DenseMap", "<", "MachineBasicBlock", "*", ",", "unsigned", "int", ">", "::", "iterator", "I", "=", "ReturnBBs", ".", "begin", "(", ")", ";", "I", "!=", "ReturnBBs", ".", "end", "(", ")", ";", "++", "I", ")", "{", "MBB", "=", "I", "->", "first", ";", "Cycles", "=", "I", "->", "second", ";", "if", "(", "Cycles", "<", "Threshold", ")", "{", "assert", "(", "MBB", "->", "size", "(", ")", ">", "0", "&&", "\"Basic block should contain at least a RET but is empty\"", ")", ";", "MachineBasicBlock", "::", "iterator", "ReturnLoc", "=", "--", "MBB", "->", "end", "(", ")", ";", "while", "(", "ReturnLoc", "->", "isDebugValue", "(", ")", ")", "--", "ReturnLoc", ";", "assert", "(", "ReturnLoc", "->", "isReturn", "(", ")", "&&", "!", "ReturnLoc", "->", "isCall", "(", ")", "&&", "\"Basic block does not end with RET\"", ")", ";", "addPadding", "(", "MBB", ",", "ReturnLoc", ",", "Threshold", "-", "Cycles", ")", ";", "NumBBsPadded", "++", ";", "MadeChange", "=", "true", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "\"Basic block should contain at least a RET but is empty\"", "\"Basic block does not end with RET\"" ]

[]

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

[ "getBranchTargetOpValue", "-", "Return", "binary", "encoding", "of", "the", "microMIPS", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "1", "\"getBranchTargetOpValueMM expects only expressions or immediates\"", "0", "Mips", "0" ]

[]

[ "<s>", "const", "char", "*", "avr_out_compare64", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "xop", "[", "3", "]", ";", "xop", "[", "0", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "18", ")", ";", "xop", "[", "1", "]", "=", "op", "[", "0", "]", ";", "xop", "[", "2", "]", "=", "op", "[", "1", "]", ";", "return", "avr_out_compare", "(", "insn", ",", "xop", ",", "plen", ")", ";", "}", "</s>" ]

[ "Prepare", "operands", "of", "compare_const_di2", "to", "be", "used", "with", "avr_out_compare", "." ]

[ "avr", "3", "0", "18", "1", "0", "2", "1" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "v32i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "1", ";", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "16", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "64", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "return", "VT", ".", "getVectorNumElements", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "v32i16", "||", "VT", "==", "MVT", "::", "v64i8", ")", "&&", "!", "EnableOldKNLABI", "&&", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "return", "1", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "X86", "X86", "MVT::v32i1", "1", "MVT::i1", "16", "64", "MVT::v32i16", "MVT::v64i8", "1" ]

[]

[ "<s>", "MachineInstr", "*", "PPCInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "PPC", "::", "RLWIMI", ")", "return", "TargetInstrInfoImpl", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "!=", "0", ")", "return", "0", ";", "unsigned", "Reg0", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Reg1", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "unsigned", "Reg2", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "bool", "Reg1IsKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "Reg2IsKill", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "isKill", "(", ")", ";", "bool", "ChangeReg0", "=", "false", ";", "if", "(", "Reg0", "==", "Reg1", ")", "{", "assert", "(", "MI", "->", "getDesc", "(", ")", ".", "getOperandConstraint", "(", "0", ",", "TOI", "::", "TIED_TO", ")", "&&", "\"Expecting a two-address instruction!\"", ")", ";", "Reg2IsKill", "=", "false", ";", "ChangeReg0", "=", "true", ";", "}", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ";", "unsigned", "ME", "=", "MI", "->", "getOperand", "(", "5", ")", ".", "getImm", "(", ")", ";", "if", "(", "NewMI", ")", "{", "unsigned", "Reg0", "=", "ChangeReg0", "?", "Reg2", ":", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "Reg0IsDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "return", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "MI", "->", "getDesc", "(", ")", ")", ".", "addReg", "(", "Reg0", ",", "true", ",", "false", ",", "false", ",", "Reg0IsDead", ")", ".", "addReg", "(", "Reg2", ",", "false", ",", "false", ",", "Reg2IsKill", ")", ".", "addReg", "(", "Reg1", ",", "false", ",", "false", ",", "Reg1IsKill", ")", ".", "addImm", "(", "(", "ME", "+", "1", ")", "&", "31", ")", ".", "addImm", "(", "(", "MB", "-", "1", ")", "&", "31", ")", ";", "}", "if", "(", "ChangeReg0", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "Reg2", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setReg", "(", "Reg1", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setReg", "(", "Reg2", ")", ";", "MI", "->", "getOperand", "(", "2", ")", ".", "setIsKill", "(", "Reg1IsKill", ")", ";", "MI", "->", "getOperand", "(", "1", ")", ".", "setIsKill", "(", "Reg2IsKill", ")", ";", "MI", "->", "getOperand", "(", "4", ")", ".", "setImm", "(", "(", "ME", "+", "1", ")", "&", "31", ")", ";", "MI", "->", "getOperand", "(", "5", ")", ".", "setImm", "(", "(", "MB", "-", "1", ")", "&", "31", ")", ";", "return", "MI", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::RLWIMI", "3", "0", "0", "0", "1", "2", "1", "2", "0", "\"Expecting a two-address instruction!\"", "4", "5", "0", "0", "1", "31", "1", "31", "0", "2", "1", "2", "1", "4", "1", "31", "5", "1", "31" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown Fixup Kind!\"", ")", ";", "case", "fixup_Hexagon_LO16", ":", "case", "fixup_Hexagon_HI16", ":", "case", "fixup_Hexagon_16", ":", "case", "fixup_Hexagon_8", ":", "case", "fixup_Hexagon_GPREL16_0", ":", "case", "fixup_Hexagon_GPREL16_1", ":", "case", "fixup_Hexagon_GPREL16_2", ":", "case", "fixup_Hexagon_GPREL16_3", ":", "case", "fixup_Hexagon_HL16", ":", "case", "fixup_Hexagon_32_6_X", ":", "case", "fixup_Hexagon_16_X", ":", "case", "fixup_Hexagon_12_X", ":", "case", "fixup_Hexagon_11_X", ":", "case", "fixup_Hexagon_10_X", ":", "case", "fixup_Hexagon_9_X", ":", "case", "fixup_Hexagon_8_X", ":", "case", "fixup_Hexagon_7_X", ":", "case", "fixup_Hexagon_6_X", ":", "case", "fixup_Hexagon_COPY", ":", "case", "fixup_Hexagon_GLOB_DAT", ":", "case", "fixup_Hexagon_JMP_SLOT", ":", "case", "fixup_Hexagon_RELATIVE", ":", "case", "fixup_Hexagon_PLT_B22_PCREL", ":", "case", "fixup_Hexagon_GOTREL_LO16", ":", "case", "fixup_Hexagon_GOTREL_HI16", ":", "case", "fixup_Hexagon_GOTREL_32", ":", "case", "fixup_Hexagon_GOT_LO16", ":", "case", "fixup_Hexagon_GOT_HI16", ":", "case", "fixup_Hexagon_GOT_32", ":", "case", "fixup_Hexagon_GOT_16", ":", "case", "fixup_Hexagon_DTPMOD_32", ":", "case", "fixup_Hexagon_DTPREL_LO16", ":", "case", "fixup_Hexagon_DTPREL_HI16", ":", "case", "fixup_Hexagon_DTPREL_32", ":", "case", "fixup_Hexagon_DTPREL_16", ":", "case", "fixup_Hexagon_GD_PLT_B22_PCREL", ":", "case", "fixup_Hexagon_LD_PLT_B22_PCREL", ":", "case", "fixup_Hexagon_GD_GOT_LO16", ":", "case", "fixup_Hexagon_GD_GOT_HI16", ":", "case", "fixup_Hexagon_GD_GOT_32", ":", "case", "fixup_Hexagon_GD_GOT_16", ":", "case", "fixup_Hexagon_LD_GOT_LO16", ":", "case", "fixup_Hexagon_LD_GOT_HI16", ":", "case", "fixup_Hexagon_LD_GOT_32", ":", "case", "fixup_Hexagon_LD_GOT_16", ":", "case", "fixup_Hexagon_IE_LO16", ":", "case", "fixup_Hexagon_IE_HI16", ":", "case", "fixup_Hexagon_IE_32", ":", "case", "fixup_Hexagon_IE_16", ":", "case", "fixup_Hexagon_IE_GOT_LO16", ":", "case", "fixup_Hexagon_IE_GOT_HI16", ":", "case", "fixup_Hexagon_IE_GOT_32", ":", "case", "fixup_Hexagon_IE_GOT_16", ":", "case", "fixup_Hexagon_TPREL_LO16", ":", "case", "fixup_Hexagon_TPREL_HI16", ":", "case", "fixup_Hexagon_TPREL_32", ":", "case", "fixup_Hexagon_TPREL_16", ":", "case", "fixup_Hexagon_GOTREL_32_6_X", ":", "case", "fixup_Hexagon_GOTREL_16_X", ":", "case", "fixup_Hexagon_GOTREL_11_X", ":", "case", "fixup_Hexagon_GOT_32_6_X", ":", "case", "fixup_Hexagon_GOT_16_X", ":", "case", "fixup_Hexagon_GOT_11_X", ":", "case", "fixup_Hexagon_DTPREL_32_6_X", ":", "case", "fixup_Hexagon_DTPREL_16_X", ":", "case", "fixup_Hexagon_DTPREL_11_X", ":", "case", "fixup_Hexagon_GD_GOT_32_6_X", ":", "case", "fixup_Hexagon_GD_GOT_16_X", ":", "case", "fixup_Hexagon_GD_GOT_11_X", ":", "case", "fixup_Hexagon_LD_GOT_32_6_X", ":", "case", "fixup_Hexagon_LD_GOT_16_X", ":", "case", "fixup_Hexagon_LD_GOT_11_X", ":", "case", "fixup_Hexagon_IE_32_6_X", ":", "case", "fixup_Hexagon_IE_16_X", ":", "case", "fixup_Hexagon_IE_GOT_32_6_X", ":", "case", "fixup_Hexagon_IE_GOT_16_X", ":", "case", "fixup_Hexagon_IE_GOT_11_X", ":", "case", "fixup_Hexagon_TPREL_32_6_X", ":", "case", "fixup_Hexagon_TPREL_16_X", ":", "case", "fixup_Hexagon_TPREL_11_X", ":", "case", "fixup_Hexagon_32_PCREL", ":", "case", "fixup_Hexagon_6_PCREL_X", ":", "case", "fixup_Hexagon_23_REG", ":", "case", "fixup_Hexagon_27_REG", ":", "case", "fixup_Hexagon_GD_PLT_B22_PCREL_X", ":", "case", "fixup_Hexagon_GD_PLT_B32_PCREL_X", ":", "case", "fixup_Hexagon_LD_PLT_B22_PCREL_X", ":", "case", "fixup_Hexagon_LD_PLT_B32_PCREL_X", ":", "return", "true", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B13_PCREL_X", ":", "case", "fixup_Hexagon_B32_PCREL_X", ":", "case", "fixup_Hexagon_B22_PCREL_X", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL_X", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL_X", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL_X", ":", "if", "(", "DisableFixup", ")", "return", "true", ";", "break", ";", "case", "FK_Data_1", ":", "case", "FK_Data_2", ":", "case", "FK_Data_4", ":", "case", "FK_PCRel_4", ":", "case", "fixup_Hexagon_32", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Unknown Fixup Kind!\"", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "bool", "function_resolver", "::", "require_matching_integer_scalar_type", "(", "unsigned", "int", "argno", ",", "unsigned", "int", "first_argno", ",", "type_suffix_index", "expected_type", ")", "{", "type_suffix_index", "actual_type", "=", "infer_integer_scalar_type", "(", "argno", ")", ";", "if", "(", "actual_type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "false", ";", "if", "(", "actual_type", "==", "expected_type", ")", "return", "true", ";", "error_at", "(", "location", ",", "\"call to %qE is ambiguous; argument %d has type\"", "\" %qs but argument %d has type %qs\"", ",", "fndecl", ",", "first_argno", "+", "1", ",", "get_scalar_type_name", "(", "expected_type", ")", ",", "argno", "+", "1", ",", "get_scalar_type_name", "(", "actual_type", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Argument", "FIRST_ARGNO", "is", "a", "scalar", "with", "type", "EXPECTED_TYPE", ",", "and", "argument", "ARGNO", "should", "be", "consistent", "with", "it", ".", "Return", "true", "if", "it", "is", ",", "otherwise", "report", "an", "appropriate", "error", "." ]

[ "aarch64", "\"call to %qE is ambiguous; argument %d has type\"", "\" %qs but argument %d has type %qs\"", "1", "1" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "RISCVAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"fixup_riscv_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_pcrel_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_i\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_pcrel_lo12_s\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "|", "MCFixupKindInfo", "::", "FKF_IsTarget", "}", ",", "{", "\"fixup_riscv_got_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_tprel_hi20\"", ",", "12", ",", "20", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_lo12_i\"", ",", "20", ",", "12", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_lo12_s\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_riscv_tprel_add\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_tls_got_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_tls_gd_hi20\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_jal\"", ",", "12", ",", "20", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_branch\"", ",", "0", ",", "32", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_jump\"", ",", "2", ",", "11", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_rvc_branch\"", ",", "0", ",", "16", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_call_plt\"", ",", "0", ",", "64", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_riscv_relax\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_riscv_align\"", ",", "0", ",", "0", ",", "0", "}", ",", "{", "\"fixup_pulpv2_loop_setup\"", ",", "20", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_pulpv2_loop_setupi\"", ",", "15", ",", "5", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "static_assert", "(", "(", "array_lengthof", "(", "Infos", ")", ")", "==", "RISCV", "::", "NumTargetFixupKinds", ",", "\"Not all fixup kinds added to Infos array\"", ")", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "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", "." ]

[ "RI5CY", "RISCV", "\"fixup_riscv_hi20\"", "12", "20", "0", "\"fixup_riscv_lo12_i\"", "20", "12", "0", "\"fixup_riscv_lo12_s\"", "0", "32", "0", "\"fixup_riscv_pcrel_hi20\"", "12", "20", "\"fixup_riscv_pcrel_lo12_i\"", "20", "12", "\"fixup_riscv_pcrel_lo12_s\"", "0", "32", "\"fixup_riscv_got_hi20\"", "12", "20", "\"fixup_riscv_tprel_hi20\"", "12", "20", "0", "\"fixup_riscv_tprel_lo12_i\"", "20", "12", "0", "\"fixup_riscv_tprel_lo12_s\"", "0", "32", "0", "\"fixup_riscv_tprel_add\"", "0", "0", "0", "\"fixup_riscv_tls_got_hi20\"", "12", "20", "\"fixup_riscv_tls_gd_hi20\"", "12", "20", "\"fixup_riscv_jal\"", "12", "20", "\"fixup_riscv_branch\"", "0", "32", "\"fixup_riscv_rvc_jump\"", "2", "11", "\"fixup_riscv_rvc_branch\"", "0", "16", "\"fixup_riscv_call\"", "0", "64", "\"fixup_riscv_call_plt\"", "0", "64", "\"fixup_riscv_relax\"", "0", "0", "0", "\"fixup_riscv_align\"", "0", "0", "0", "\"fixup_pulpv2_loop_setup\"", "20", "12", "\"fixup_pulpv2_loop_setupi\"", "15", "5", "RISCV::NumTargetFixupKinds", "\"Not all fixup kinds added to Infos array\"", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "LanaiTargetObjectFile", "::", "isGlobalInSmallSection", "(", "const", "GlobalObject", "*", "GO", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "return", "isGlobalInSmallSectionImpl", "(", "GO", ",", "TM", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "SITypeRewriter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "v16i8", "=", "VectorType", "::", "get", "(", "Type", "::", "getInt8Ty", "(", "M", ".", "getContext", "(", ")", ")", ",", "16", ")", ";", "i128", "=", "Type", "::", "getIntNTy", "(", "M", ".", "getContext", "(", ")", ",", "128", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "R600", "SI", "16", "128" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Large", ")", ",", "OL", ")", ",", "TLOF", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-n32:64-S128\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128\"", "WebAssembly" ]

[]

[ "<s>", "bool", "easy_altivec_constant", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "step", ",", "copies", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "else", "if", "(", "mode", "!=", "GET_MODE", "(", "op", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "V2DFmode", ")", "return", "zero_constant", "(", "op", ",", "mode", ")", ";", "else", "if", "(", "mode", "==", "V2DImode", ")", "{", "if", "(", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", "!=", "CONST_INT", "||", "GET_CODE", "(", "CONST_VECTOR_ELT", "(", "op", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "if", "(", "zero_constant", "(", "op", ",", "mode", ")", ")", "return", "true", ";", "if", "(", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ")", "==", "-", "1", "&&", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "1", ")", ")", "==", "-", "1", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "mode", "==", "V1TImode", ")", "return", "false", ";", "step", "=", "GET_MODE_NUNITS", "(", "mode", ")", "/", "4", ";", "copies", "=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "true", ";", "if", "(", "vspltis_shifted", "(", "op", ")", "!=", "0", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "of", "the", "given", "MODE", "and", "can", "be", "synthesized", "with", "a", "vspltisb", ",", "vspltish", "or", "vspltisw", "." ]

[ "rs6000", "0", "1", "0", "1", "1", "1", "4", "1", "1", "1", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "static", "int", "riscv_split_integer_cost", "(", "HOST_WIDE_INT", "val", ")", "{", "int", "cost", ";", "unsigned", "HOST_WIDE_INT", "loval", "=", "sext_hwi", "(", "val", ",", "32", ")", ";", "unsigned", "HOST_WIDE_INT", "hival", "=", "sext_hwi", "(", "(", "val", "-", "loval", ")", ">>", "32", ",", "32", ")", ";", "struct", "riscv_integer_op", "codes", "[", "RISCV_MAX_INTEGER_OPS", "]", ";", "cost", "=", "2", "+", "riscv_build_integer", "(", "codes", ",", "loval", ",", "VOIDmode", ")", ";", "if", "(", "loval", "!=", "hival", ")", "cost", "+=", "riscv_build_integer", "(", "codes", ",", "hival", ",", "VOIDmode", ")", ";", "return", "cost", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "constructing", "VAL", "in", "the", "event", "that", "a", "scratch", "register", "is", "available", "." ]

[ "riscv", "32", "32", "32", "2" ]

[]

[ "<s>", "static", "void", "core2i7_first_cycle_multipass_issue", "(", "void", "*", "_data", ",", "signed", "char", "*", "ready_try", ",", "int", "n_ready", ",", "rtx_insn", "*", "insn", ",", "const", "void", "*", "_prev_data", ")", "{", "ix86_first_cycle_multipass_data_t", "data", "=", "(", "ix86_first_cycle_multipass_data_t", ")", "_data", ";", "const_ix86_first_cycle_multipass_data_t", "prev_data", "=", "(", "const_ix86_first_cycle_multipass_data_t", ")", "_prev_data", ";", "int", "insn_size", "=", "min_insn_size", "(", "insn", ")", ";", "data", "->", "ifetch_block_len", "=", "prev_data", "->", "ifetch_block_len", "+", "insn_size", ";", "data", "->", "ifetch_block_n_insns", "=", "prev_data", "->", "ifetch_block_n_insns", "+", "1", ";", "gcc_assert", "(", "data", "->", "ifetch_block_len", "<=", "core2i7_ifetch_block_size", "&&", "data", "->", "ifetch_block_n_insns", "<=", "core2i7_ifetch_block_max_insns", ")", ";", "if", "(", "!", "data", "->", "ready_try_change", ")", "{", "data", "->", "ready_try_change", "=", "sbitmap_alloc", "(", "n_ready", ")", ";", "data", "->", "ready_try_change_size", "=", "n_ready", ";", "}", "else", "if", "(", "data", "->", "ready_try_change_size", "<", "n_ready", ")", "{", "data", "->", "ready_try_change", "=", "sbitmap_resize", "(", "data", "->", "ready_try_change", ",", "n_ready", ",", "0", ")", ";", "data", "->", "ready_try_change_size", "=", "n_ready", ";", "}", "bitmap_clear", "(", "data", "->", "ready_try_change", ")", ";", "core2i7_first_cycle_multipass_filter_ready_try", "(", "data", ",", "ready_try", ",", "n_ready", ",", "false", ")", ";", "}", "</s>" ]

[ "INSN", "is", "being", "issued", "in", "current", "solution", ".", "Account", "for", "its", "impact", "on", "the", "decoder", "model", "." ]

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

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "isPIC", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", ";", "if", "(", "MFI", "->", "hasCalls", "(", ")", "&&", "isPIC", ")", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setObjectOffset", "(", "MipsFI", "->", "getGPFI", "(", ")", ",", "MipsFI", "->", "getGPStackOffset", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "riscv_verify_type_context", "(", "location_t", "loc", ",", "type_context_kind", "context", ",", "const_tree", "type", ",", "bool", "silent_p", ")", "{", "return", "riscv_vector", "::", "verify_type_context", "(", "loc", ",", "context", ",", "type", ",", "silent_p", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VERIFY_TYPE_CONTEXT", "." ]

[ "riscv", "riscv_vector::verify_type_context" ]

[]

[ "<s>", "Value", "*", "X86TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRBuilder", "<", ">", "&", "IRB", ")", "const", "{", "if", "(", "Subtarget", ".", "getTargetTriple", "(", ")", ".", "isOSContiki", "(", ")", ")", "return", "getDefaultSafeStackPointerLocation", "(", "IRB", ",", "false", ")", ";", "if", "(", "Subtarget", ".", "isTargetAndroid", "(", ")", ")", "{", "int", "Offset", "=", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "?", "0x48", ":", "0x24", ";", "return", "SegmentOffset", "(", "IRB", ",", "Offset", ",", "getAddressSpace", "(", ")", ")", ";", "}", "if", "(", "Subtarget", ".", "isTargetFuchsia", "(", ")", ")", "{", "return", "SegmentOffset", "(", "IRB", ",", "0x18", ",", "getAddressSpace", "(", ")", ")", ";", "}", "return", "TargetLowering", "::", "getSafeStackPointerLocation", "(", "IRB", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "stores", "SafeStack", "pointer", "at", "a", "fixed", "offset", "in", "some", "non-standard", "address", "space", ",", "and", "populates", "the", "address", "space", "and", "offset", "as", "appropriate", "." ]

[ "X86", "X86", "0x48", "0x24", "0x18" ]

[]

[ "<s>", "bool", "rs6000_overloaded_builtin_p", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "return", "(", "rs6000_builtin_info", "[", "(", "int", ")", "fncode", "]", ".", "attr", "&", "RS6000_BTC_OVERLOADED", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "builtin", "function", "is", "overloaded", "." ]

[ "powerpcspe", "0" ]

[]

[ "<s>", "static", "tree", "avr_handle_fndecl_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "attribute", "requiring", "a", "FUNCTION_DECL", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "avr", "\"%qE attribute only applies to functions\"" ]

[]

[ "<s>", "bool", "gen_operands_ldd_std", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "bool", "commute", ")", "{", "int", "i", ",", "gap", ";", "HOST_WIDE_INT", "offsets", "[", "2", "]", ",", "offset", ";", "int", "nops", "=", "2", ";", "rtx", "cur_base", ",", "cur_offset", ",", "tmp", ";", "rtx", "base", "=", "NULL_RTX", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nops", ";", "i", "++", ")", "{", "if", "(", "!", "mem_ok_for_ldd_std", "(", "operands", "[", "nops", "+", "i", "]", ",", "&", "cur_base", ",", "&", "cur_offset", ")", ")", "return", "false", ";", "if", "(", "i", "==", "0", ")", "base", "=", "cur_base", ";", "else", "if", "(", "REGNO", "(", "base", ")", "!=", "REGNO", "(", "cur_base", ")", ")", "return", "false", ";", "offsets", "[", "i", "]", "=", "INTVAL", "(", "cur_offset", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "i", "]", ")", "==", "SUBREG", ")", "{", "tmp", "=", "SUBREG_REG", "(", "operands", "[", "i", "]", ")", ";", "gcc_assert", "(", "GET_MODE", "(", "operands", "[", "i", "]", ")", "==", "GET_MODE", "(", "tmp", ")", ")", ";", "operands", "[", "i", "]", "=", "tmp", ";", "}", "}", "if", "(", "load", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "base", ")", ")", "return", "false", ";", "if", "(", "load", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "return", "false", ";", "if", "(", "offsets", "[", "0", "]", ">", "offsets", "[", "1", "]", ")", "{", "gap", "=", "offsets", "[", "0", "]", "-", "offsets", "[", "1", "]", ";", "offset", "=", "offsets", "[", "1", "]", ";", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "std", "::", "swap", "(", "operands", "[", "2", "]", ",", "operands", "[", "3", "]", ")", ";", "}", "else", "{", "gap", "=", "offsets", "[", "1", "]", "-", "offsets", "[", "0", "]", ";", "offset", "=", "offsets", "[", "0", "]", ";", "}", "if", "(", "gap", "!=", "4", ")", "return", "false", ";", "if", "(", "operands_ok_ldd_std", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "offset", ")", ")", "return", "true", ";", "if", "(", "load", "&&", "commute", ")", "{", "std", "::", "swap", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "operands_ok_ldd_std", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "offset", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Called", "from", "peephole2", "to", "replace", "two", "word-size", "accesses", "with", "a", "single", "LDD/STD", "instruction", ".", "Returns", "true", "iff", "we", "can", "generate", "a", "new", "instruction", "sequence", ".", "That", "is", ",", "both", "accesses", "use", "the", "same", "base", "register", "and", "the", "gap", "between", "constant", "offsets", "is", "4", ".", "OPERANDS", "are", "the", "operands", "found", "by", "the", "peephole", "matcher", ";", "OPERANDS", "[", "0,1", "]", "are", "register", "operands", ",", "and", "OPERANDS", "[", "2,3", "]", "are", "the", "corresponding", "memory", "operands", ".", "LOAD", "indicates", "whether", "the", "access", "is", "load", "or", "store", "." ]

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

[]

[ "<s>", "MipsSubtarget", "::", "MipsSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "little", ",", "Reloc", "::", "Model", "RM", ")", ":", "MipsGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "MipsArchVersion", "(", "Mips32", ")", ",", "MipsABI", "(", "UnknownABI", ")", ",", "IsLittle", "(", "little", ")", ",", "IsSingleFloat", "(", "false", ")", ",", "IsFP64bit", "(", "false", ")", ",", "IsGP64bit", "(", "false", ")", ",", "HasVFPU", "(", "false", ")", ",", "IsLinux", "(", "true", ")", ",", "HasSEInReg", "(", "false", ")", ",", "HasCondMov", "(", "false", ")", ",", "HasMulDivAdd", "(", "false", ")", ",", "HasMinMax", "(", "false", ")", ",", "HasSwap", "(", "false", ")", ",", "HasBitCount", "(", "false", ")", ",", "HasFPIdx", "(", "false", ")", ",", "InMips16Mode", "(", "false", ")", ",", "HasDSP", "(", "false", ")", ",", "HasDSPR2", "(", "false", ")", ",", "IsAndroid", "(", "false", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"mips32\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "InstrItins", "=", "getInstrItineraryForCPU", "(", "CPUName", ")", ";", "if", "(", "MipsABI", "==", "UnknownABI", ")", "MipsABI", "=", "hasMips64", "(", ")", "?", "N64", ":", "O32", ";", "assert", "(", "(", "(", "!", "hasMips64", "(", ")", "&&", "(", "isABI_O32", "(", ")", "||", "isABI_EABI", "(", ")", ")", ")", "||", "(", "hasMips64", "(", ")", "&&", "(", "isABI_N32", "(", ")", "||", "isABI_N64", "(", ")", ")", ")", ")", "&&", "\"Invalid Arch & ABI pair.\"", ")", ";", "if", "(", "TT", ".", "find", "(", "\"linux\"", ")", "==", "std", "::", "string", "::", "npos", ")", "IsLinux", "=", "false", ";", "UseSmallSection", "=", "!", "IsLinux", "&&", "(", "RM", "==", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "\"mips32\"", "Mips", "Mips", "Mips", "Mips", "Mips", "\"Invalid Arch & ABI pair.\"", "\"linux\"" ]

[]

[ "<s>", "unsigned", "M680x0RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addFastRegAlloc", "(", ")", "{", "insertPass", "(", "&", "PHIEliminationID", ",", "&", "SILowerControlFlowID", ",", "false", ")", ";", "insertPass", "(", "&", "SILowerControlFlowID", ",", "&", "SIFixWWMLivenessID", ",", "false", ")", ";", "TargetPassConfig", "::", "addFastRegAlloc", "(", ")", ";", "}", "</s>" ]

[ "addFastRegAlloc", "-", "Add", "the", "minimum", "set", "of", "target-independent", "passes", "that", "are", "required", "for", "fast", "register", "allocation", "." ]

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

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedLoad", "(", "Type", "*", "DataTy", ")", "{", "if", "(", "!", "ST", "->", "hasAVX", "(", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "VectorType", ">", "(", "DataTy", ")", "&&", "DataTy", "->", "getVectorNumElements", "(", ")", "==", "1", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "if", "(", "ScalarTy", "->", "isPointerTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isFloatTy", "(", ")", "||", "ScalarTy", "->", "isDoubleTy", "(", ")", ")", "return", "true", ";", "if", "(", "!", "ScalarTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "unsigned", "IntWidth", "=", "ScalarTy", "->", "getIntegerBitWidth", "(", ")", ";", "return", "IntWidth", "==", "32", "||", "IntWidth", "==", "64", "||", "(", "(", "IntWidth", "==", "8", "||", "IntWidth", "==", "16", ")", "&&", "ST", "->", "hasBWI", "(", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "1", "32", "64", "8", "16" ]

[]

[ "<s>", "unsigned", "SPURegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "int", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "MachineOperand", "&", "SPOp", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "int", "FrameIndex", "=", "SPOp", ".", "getIndex", "(", ")", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "unsigned", "OpNo", "=", "1", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "AIr32", "||", "MI", ".", "getOpcode", "(", ")", "==", "SPU", "::", "ILAr32", ")", "OpNo", "=", "2", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "Offset", "+=", "MO", ".", "getImm", "(", ")", "+", "MFI", "->", "getStackSize", "(", ")", "+", "SPUFrameInfo", "::", "minStackSize", "(", ")", ";", "assert", "(", "(", "Offset", "&", "0xf", ")", "==", "0", "&&", "\"16-byte alignment violated in eliminateFrameIndex\"", ")", ";", "SPOp", ".", "ChangeToRegister", "(", "SPU", "::", "R1", ",", "false", ")", ";", "if", "(", "Offset", ">", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", "||", "Offset", "<", "SPUFrameInfo", "::", "minFrameOffset", "(", ")", ")", "{", "errs", "(", ")", "<<", "\"Large stack adjustment (\"", "<<", "Offset", "<<", "\") in SPURegisterInfo::eliminateFrameIndex.\"", ";", "}", "else", "{", "MO", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "SPU::AIr32", "SPU::ILAr32", "2", "SPU", "0xf", "0", "\"16-byte alignment violated in eliminateFrameIndex\"", "SPU::R1", "SPU", "SPU", "\"Large stack adjustment (\"", "\") in SPURegisterInfo::eliminateFrameIndex.\"", "0" ]

[]

[ "<s>", "static", "void", "unicosmk_output_addr_vec", "(", "FILE", "*", "file", ",", "rtx", "vec", ")", "{", "rtx", "lab", "=", "XEXP", "(", "vec", ",", "0", ")", ";", "rtx", "body", "=", "XEXP", "(", "vec", ",", "1", ")", ";", "int", "vlen", "=", "XVECLEN", "(", "body", ",", "0", ")", ";", "int", "idx", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "lab", ")", ")", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "ASM_OUTPUT_ADDR_VEC_ELT", "(", "file", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XVECEXP", "(", "body", ",", "0", ",", "idx", ")", ",", "0", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "case", "vector", "." ]

[ "alpha", "0", "1", "0", "\"L\"", "0", "0", "0" ]

[]

[ "<s>", "const", "AlphaTargetMachine", "&", "getTargetMachine", "(", ")", "{", "return", "static_cast", "<", "const", "AlphaTargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

[ "Alpha", "Alpha", "Alpha" ]

[]

[ "<s>", "static", "bool", "h8300_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "mode1", "==", "mode2", "||", "(", "(", "mode1", "==", "QImode", "||", "mode1", "==", "HImode", "||", "mode1", "==", "SImode", ")", "&&", "(", "mode2", "==", "QImode", "||", "mode2", "==", "HImode", "||", "mode2", "==", "SImode", ")", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "h8300" ]

[]

[ "<s>", "static", "tree", "s390_build_builtin_va_list", "(", "void", ")", "{", "tree", "f_gpr", ",", "f_fpr", ",", "f_ovf", ",", "f_sav", ",", "record", ",", "type_decl", ";", "record", "=", "lang_hooks", ".", "types", ".", "make_type", "(", "RECORD_TYPE", ")", ";", "type_decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "TYPE_DECL", ",", "get_identifier", "(", "\"__va_list_tag\"", ")", ",", "record", ")", ";", "f_gpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__gpr\"", ")", ",", "long_integer_type_node", ")", ";", "f_fpr", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__fpr\"", ")", ",", "long_integer_type_node", ")", ";", "f_ovf", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__overflow_arg_area\"", ")", ",", "ptr_type_node", ")", ";", "f_sav", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FIELD_DECL", ",", "get_identifier", "(", "\"__reg_save_area\"", ")", ",", "ptr_type_node", ")", ";", "va_list_gpr_counter_field", "=", "f_gpr", ";", "va_list_fpr_counter_field", "=", "f_fpr", ";", "DECL_FIELD_CONTEXT", "(", "f_gpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_fpr", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_ovf", ")", "=", "record", ";", "DECL_FIELD_CONTEXT", "(", "f_sav", ")", "=", "record", ";", "TYPE_STUB_DECL", "(", "record", ")", "=", "type_decl", ";", "TYPE_NAME", "(", "record", ")", "=", "type_decl", ";", "TYPE_FIELDS", "(", "record", ")", "=", "f_gpr", ";", "DECL_CHAIN", "(", "f_gpr", ")", "=", "f_fpr", ";", "DECL_CHAIN", "(", "f_fpr", ")", "=", "f_ovf", ";", "DECL_CHAIN", "(", "f_ovf", ")", "=", "f_sav", ";", "layout_type", "(", "record", ")", ";", "return", "build_array_type", "(", "record", ",", "build_index_type", "(", "size_zero_node", ")", ")", ";", "}", "</s>" ]

[ "Create", "and", "return", "the", "va_list", "datatype", ".", "On", "S/390", ",", "va_list", "is", "an", "array", "type", "equivalent", "to", "typedef", "struct", "__va_list_tag", "{", "long", "__gpr", ";", "long", "__fpr", ";", "void", "*", "__overflow_arg_area", ";", "void", "*", "__reg_save_area", ";", "}", "va_list", "[", "1", "]", ";", "where", "__gpr", "and", "__fpr", "hold", "the", "number", "of", "general", "purpose", "or", "floating", "point", "arguments", "used", "up", "to", "now", ",", "respectively", ",", "__overflow_arg_area", "points", "to", "the", "stack", "location", "of", "the", "next", "argument", "passed", "on", "the", "stack", ",", "and", "__reg_save_area", "always", "points", "to", "the", "start", "of", "the", "register", "area", "in", "the", "call", "frame", "of", "the", "current", "function", ".", "The", "function", "prologue", "saves", "all", "registers", "used", "for", "argument", "passing", "into", "this", "area", "if", "the", "function", "uses", "variable", "arguments", "." ]

[ "s390", "\"__va_list_tag\"", "\"__gpr\"", "\"__fpr\"", "\"__overflow_arg_area\"", "\"__reg_save_area\"" ]

[]

[ "<s>", "unsigned", "CJGInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "1", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"CJG branch conditions have one component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CJG", "::", "JMP", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "unsigned", "Count", "=", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CJG", "::", "JCC", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addImm", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "++", "Count", ";", "if", "(", "FBB", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "CJG", "::", "JMP", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "CJG", "CJG", "\"insertBranch must not be told to insert a fallthrough\"", "1", "0", "\"CJG branch conditions have one component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "CJG::JMP", "1", "0", "CJG::JCC", "0", "CJG::JMP" ]

[]

[ "<s>", "void", "ix86_split_copysign_var", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "scratch", ",", "op0", ",", "op1", ",", "mask", ",", "nmask", ",", "x", ";", "dest", "=", "operands", "[", "0", "]", ";", "scratch", "=", "operands", "[", "1", "]", ";", "op0", "=", "operands", "[", "2", "]", ";", "op1", "=", "operands", "[", "3", "]", ";", "nmask", "=", "operands", "[", "4", "]", ";", "mask", "=", "operands", "[", "5", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "vmode", "=", "GET_MODE", "(", "mask", ")", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "{", "emit_move_insn", "(", "dest", ",", "op0", ")", ";", "return", ";", "}", "if", "(", "REG_P", "(", "mask", ")", "&&", "REGNO", "(", "dest", ")", "==", "REGNO", "(", "mask", ")", ")", "{", "gcc_assert", "(", "REGNO", "(", "op1", ")", "==", "REGNO", "(", "scratch", ")", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "scratch", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "scratch", ",", "x", ")", ")", ";", "dest", "=", "mask", ";", "op0", "=", "simplify_gen_subreg", "(", "vmode", ",", "op0", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_NOT", "(", "vmode", ",", "dest", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "x", ",", "op0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "}", "else", "{", "if", "(", "REGNO", "(", "op1", ")", "==", "REGNO", "(", "scratch", ")", ")", "{", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "scratch", ",", "mask", ")", ";", "}", "else", "{", "gcc_assert", "(", "REGNO", "(", "mask", ")", "==", "REGNO", "(", "scratch", ")", ")", ";", "op1", "=", "simplify_gen_subreg", "(", "vmode", ",", "op1", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "scratch", ",", "op1", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "scratch", ",", "x", ")", ")", ";", "if", "(", "REGNO", "(", "op0", ")", "==", "REGNO", "(", "dest", ")", ")", "{", "dest", "=", "simplify_gen_subreg", "(", "vmode", ",", "op0", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "nmask", ")", ";", "}", "else", "{", "gcc_assert", "(", "REGNO", "(", "nmask", ")", "==", "REGNO", "(", "dest", ")", ")", ";", "dest", "=", "nmask", ";", "op0", "=", "simplify_gen_subreg", "(", "vmode", ",", "op0", ",", "mode", ",", "0", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "op0", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "}", "x", "=", "gen_rtx_IOR", "(", "vmode", ",", "dest", ",", "scratch", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Deconstruct", "a", "copysign", "operation", "into", "bit", "masks", ".", "Operand", "0", "is", "variable", ",", "so", "we", "have", "to", "do", "two", "masks", "." ]

[ "i386", "0", "1", "2", "3", "4", "5", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "useLoadStackGuardNode", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ" ]

[]

[ "<s>", "const", "char", "*", "m68k_output_branch_integer_rev", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"jne %l3\"", ";", "case", "NE", ":", "return", "\"jeq %l3\"", ";", "case", "GT", ":", "return", "\"jle %l3\"", ";", "case", "GTU", ":", "return", "\"jls %l3\"", ";", "case", "LT", ":", "return", "\"jge %l3\"", ";", "case", "LTU", ":", "return", "\"jcc %l3\"", ";", "case", "GE", ":", "return", "\"jlt %l3\"", ";", "case", "GEU", ":", "return", "\"jcs %l3\"", ";", "case", "LE", ":", "return", "\"jgt %l3\"", ";", "case", "LEU", ":", "return", "\"jhi %l3\"", ";", "case", "PLUS", ":", "return", "\"jmi %l3\"", ";", "case", "MINUS", ":", "return", "\"jpl %l3\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "output", "template", "for", "a", "reversed", "branch", "with", "CODE", "." ]

[ "m68k", "\"jne %l3\"", "\"jeq %l3\"", "\"jle %l3\"", "\"jls %l3\"", "\"jge %l3\"", "\"jcc %l3\"", "\"jlt %l3\"", "\"jcs %l3\"", "\"jgt %l3\"", "\"jhi %l3\"", "\"jmi %l3\"", "\"jpl %l3\"" ]

[]

[ "<s>", "SystemZConstantPoolValue", "*", "SystemZConstantPoolValue", "::", "Create", "(", "const", "GlobalValue", "*", "GV", ",", "SystemZCP", "::", "SystemZCPModifier", "Modifier", ")", "{", "return", "new", "SystemZConstantPoolValue", "(", "GV", ",", "Modifier", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZCP::SystemZCPModifier", "SystemZ" ]

[]

[ "<s>", "MMIXSubtarget", "&", "MMIXSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "std", "::", "string", "CPUName", "=", "CPU", ";", "if", "(", "CPUName", ".", "empty", "(", ")", ")", "CPUName", "=", "\"generic-mmix\"", ";", "ParseSubtargetFeatures", "(", "CPUName", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "MMIX", "\"generic-mmix\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "override", "{", "Subtarget", "=", "&", "Fn", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "Fn", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "PPCInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "unsigned", "*", "OpcodesForSpill", "=", "getStoreOpcodesForSpillArray", "(", ")", ";", "const", "unsigned", "*", "End", "=", "OpcodesForSpill", "+", "SOK_LastOpcodeSpill", ";", "if", "(", "End", "!=", "std", "::", "find", "(", "OpcodesForSpill", ",", "End", ",", "Opcode", ")", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "!", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

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

[]

[ "<s>", "const", "Nios2FrameLowering", "*", "Nios2FrameLowering", "::", "create", "(", "const", "Nios2Subtarget", "&", "ST", ")", "{", "return", "new", "Nios2FrameLowering", "(", "ST", ",", "4", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "Nios2", "Nios2", "Nios2", "Nios2", "Nios2", "4" ]

[]

[ "<s>", "rtx", "aarch64_expand_sve_dupq", "(", "rtx", "target", ",", "machine_mode", "mode", ",", "rtx", "src", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src", ")", ";", "gcc_assert", "(", "GET_MODE_INNER", "(", "mode", ")", "==", "GET_MODE_INNER", "(", "src_mode", ")", ")", ";", "insn_code", "icode", "=", "(", "BYTES_BIG_ENDIAN", "?", "code_for_aarch64_vec_duplicate_vq_be", "(", "mode", ")", ":", "code_for_aarch64_vec_duplicate_vq_le", "(", "mode", ")", ")", ";", "unsigned", "int", "i", "=", "0", ";", "expand_operand", "ops", "[", "3", "]", ";", "create_output_operand", "(", "&", "ops", "[", "i", "++", "]", ",", "target", ",", "mode", ")", ";", "create_output_operand", "(", "&", "ops", "[", "i", "++", "]", ",", "src", ",", "src_mode", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "unsigned", "int", "nelts_per_vq", "=", "128", "/", "GET_MODE_UNIT_BITSIZE", "(", "mode", ")", ";", "rtx", "sel", "=", "aarch64_gen_stepped_int_parallel", "(", "nelts_per_vq", ",", "nelts_per_vq", "-", "1", ",", "-", "1", ")", ";", "create_fixed_operand", "(", "&", "ops", "[", "i", "++", "]", ",", "sel", ")", ";", "}", "expand_insn", "(", "icode", ",", "i", ",", "ops", ")", ";", "return", "ops", "[", "0", "]", ".", "value", ";", "}", "</s>" ]

[ "Duplicate", "128-bit", "Advanced", "SIMD", "vector", "SRC", "so", "that", "it", "fills", "an", "SVE", "register", "of", "mode", "MODE", ".", "Use", "TARGET", "for", "the", "result", "if", "it", "'s", "nonnull", "and", "convenient", ".", "The", "two", "vector", "modes", "must", "have", "the", "same", "element", "mode", ".", "The", "behavior", "is", "to", "duplicate", "architectural", "lane", "N", "of", "SRC", "into", "architectural", "lanes", "N", "+", "I", "*", "STEP", "of", "the", "result", ".", "On", "big-endian", "targets", ",", "architectural", "lane", "0", "of", "an", "Advanced", "SIMD", "vector", "is", "the", "last", "element", "of", "the", "vector", "in", "memory", "layout", ",", "so", "for", "big-endian", "targets", "this", "operation", "has", "the", "effect", "of", "reversing", "SRC", "before", "duplicating", "it", ".", "Callers", "need", "to", "account", "for", "this", "." ]

[ "aarch64", "0", "3", "128", "1", "1", "0" ]

[]

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

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

[ "Hexagon", "Hexagon", "\"vwhist256\"", "\"sat\"" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addInstSelector", "(", ")", "{", "AMDGPUPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "&", "SIFixSGPRCopiesID", ")", ";", "addPass", "(", "createSILowerI1CopiesPass", "(", ")", ")", ";", "addPass", "(", "createSIAddIMGInitPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "emitLocalCommonSymbol", "(", "MCSymbol", "*", "Symbol", ",", "uint64_t", "Size", ",", "unsigned", "ByteAlignment", ")", "override", "{", "}", "</s>" ]

[ "Emit", "a", "local", "common", "(", ".lcomm", ")", "symbol", "." ]

[ "Patmos" ]

[]

[ "<s>", "unsigned", "M680x0Subtarget", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "isPositionIndependent", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Medium", "&&", "!", "isM68020", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "return", "MachineJumpTableInfo", "::", "EK_LabelDifference32", ";", "}", "return", "MachineJumpTableInfo", "::", "EK_BlockAddress", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0" ]

[]

[ "<s>", "BitVector", "PPCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "PPCSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ";", "const", "PPCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "ZERO", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "FP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "BP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "CTR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R1", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "LR8", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "RM", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "VRSAVE", ")", ";", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "TM", ".", "isPPC64", "(", ")", "||", "FuncInfo", "->", "usesTOCBasePtr", "(", ")", "||", "MF", ".", "hasInlineAsm", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "}", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R2", ")", ";", "if", "(", "TM", ".", "isPPC64", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R13", ")", ";", "if", "(", "TFI", "->", "needsFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R31", ")", ";", "bool", "IsPositionIndependent", "=", "TM", ".", "isPositionIndependent", "(", ")", ";", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R29", ")", ";", "else", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "}", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", "&&", "IsPositionIndependent", ")", "markSuperRegs", "(", "Reserved", ",", "PPC", "::", "R30", ")", ";", "if", "(", "!", "Subtarget", ".", "hasAltivec", "(", ")", ")", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "PPC", "::", "VRRCRegClass", ".", "begin", "(", ")", ",", "IE", "=", "PPC", "::", "VRRCRegClass", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "markSuperRegs", "(", "Reserved", ",", "*", "I", ")", ";", "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", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC::ZERO", "PPC::FP", "PPC::BP", "PPC::CTR", "PPC::CTR8", "PPC::R1", "PPC::LR", "PPC::LR8", "PPC::RM", "PPC::VRSAVE", "PPC", "PPC", "PPC", "PPC::R2", "PPC::R13", "PPC::R2", "PPC", "PPC::R13", "PPC::R31", "PPC::R29", "PPC::R30", "PPC::R30", "PPC::VRRCRegClass", "PPC::VRRCRegClass" ]

[]

[ "<s>", "static", "bool", "arm_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", ",", "int", "opno", "ATTRIBUTE_UNUSED", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "bool", "result", ";", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "gcc_assert", "(", "current_tune", "->", "insn_extra_cost", ")", ";", "result", "=", "arm_rtx_costs_internal", "(", "x", ",", "(", "enum", "rtx_code", ")", "code", ",", "(", "enum", "rtx_code", ")", "outer_code", ",", "current_tune", "->", "insn_extra_cost", ",", "total", ",", "speed", ")", ";", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "{", "print_rtl_single", "(", "dump_file", ",", "x", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n%s cost: %d (%s)\\n\"", ",", "speed", "?", "\"Hot\"", ":", "\"Cold\"", ",", "*", "total", ",", "result", "?", "\"final\"", ":", "\"partial\"", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "RTX", "costs", "when", "optimizing", "for", "size", "." ]

[ "arm", "\"\\n%s cost: %d (%s)\\n\"", "\"Hot\"", "\"Cold\"", "\"final\"", "\"partial\"" ]

[]

[ "<s>", "void", "Thumb2HazardRecognizer", "::", "Reset", "(", ")", "{", "ITBlockSize", "=", "0", ";", "PostRAHazardRecognizer", "::", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "begin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "end", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "LdrOpc", ";", "if", "(", "RPI", ".", "IsGPR", ")", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPXi", ":", "AArch64", "::", "LDRXui", ";", "else", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPDi", ":", "AArch64", "::", "LDRDui", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "printReg", "(", "Reg1", ",", "TRI", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "printReg", "(", "Reg2", ",", "TRI", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "{", "MIB", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", "+", "1", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "MIB", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "RPI", ".", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "MIB", ".", "addMemOperand", "(", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "RPI", ".", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "8", ",", "8", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "8", "AArch64::LDPXi", "AArch64::LDRXui", "AArch64::LDPDi", "AArch64::LDRDui", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "1", "8", "8", "AArch64::SP", "8", "8" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "hasHighOperandLatency", "(", "const", "TargetSchedModel", "&", "SchedModel", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "const", "MachineInstr", "*", "DefMI", ",", "unsigned", "DefIdx", ",", "const", "MachineInstr", "*", "UseMI", ",", "unsigned", "UseIdx", ")", "const", "{", "unsigned", "DDomain", "=", "DefMI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "unsigned", "UDomain", "=", "UseMI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ";", "if", "(", "Subtarget", ".", "isCortexA8", "(", ")", "&&", "(", "DDomain", "==", "ARMII", "::", "DomainVFP", "||", "UDomain", "==", "ARMII", "::", "DomainVFP", ")", ")", "return", "true", ";", "unsigned", "Latency", "=", "SchedModel", ".", "computeOperandLatency", "(", "DefMI", ",", "DefIdx", ",", "UseMI", ",", "UseIdx", ")", ";", "if", "(", "Latency", "<=", "3", ")", "return", "false", ";", "return", "DDomain", "==", "ARMII", "::", "DomainVFP", "||", "DDomain", "==", "ARMII", "::", "DomainNEON", "||", "UDomain", "==", "ARMII", "::", "DomainVFP", "||", "UDomain", "==", "ARMII", "::", "DomainNEON", ";", "}", "</s>" ]

[ "Compute", "operand", "latency", "between", "a", "def", "of", "'Reg", "'", "and", "a", "use", "in", "the", "current", "loop", "." ]

[ "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainMask", "ARMII::DomainVFP", "ARMII::DomainVFP", "3", "ARMII::DomainVFP", "ARMII::DomainNEON", "ARMII::DomainVFP", "ARMII::DomainNEON" ]

[]

[ "<s>", "MVT", "::", "SimpleValueType", "Z80TargetLowering", "::", "getCmpLibcallReturnType", "(", ")", "const", "{", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "Return", "the", "ValueType", "for", "comparison", "libcalls", "." ]

[ "Z80", "MVT::SimpleValueType", "Z80", "MVT::Other" ]

[]

[ "<s>", "static", "inline", "bool", "rs6000_builtin_type_compatible", "(", "tree", "t", ",", "int", "id", ")", "{", "tree", "builtin_type", ";", "builtin_type", "=", "rs6000_builtin_type", "(", "id", ")", ";", "if", "(", "t", "==", "error_mark_node", ")", "return", "false", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "t", ")", "&&", "INTEGRAL_TYPE_P", "(", "builtin_type", ")", ")", "return", "true", ";", "else", "return", "lang_hooks", ".", "types_compatible_p", "(", "t", ",", "builtin_type", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "ARGTYPE", "can", "be", "compatibly", "passed", "as", "PARMTYPE", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "int", "avx_vperm2f128_parallel", "(", "rtx", "par", ",", "machine_mode", "mode", ")", "{", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "mode", ")", ",", "nelt2", "=", "nelt", "/", "2", ";", "unsigned", "mask", "=", "0", ";", "unsigned", "char", "ipar", "[", "8", "]", "=", "{", "}", ";", "if", "(", "XVECLEN", "(", "par", ",", "0", ")", "!=", "(", "int", ")", "nelt", ")", "return", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "rtx", "er", "=", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "ei", ";", "if", "(", "!", "CONST_INT_P", "(", "er", ")", ")", "return", "0", ";", "ei", "=", "INTVAL", "(", "er", ")", ";", "if", "(", "ei", ">=", "2", "*", "nelt", ")", "return", "0", ";", "ipar", "[", "i", "]", "=", "ei", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt2", "-", "1", ";", "++", "i", ")", "if", "(", "ipar", "[", "i", "]", "+", "1", "!=", "ipar", "[", "i", "+", "1", "]", ")", "return", "0", ";", "for", "(", "i", "=", "nelt2", ";", "i", "<", "nelt", "-", "1", ";", "++", "i", ")", "if", "(", "ipar", "[", "i", "]", "+", "1", "!=", "ipar", "[", "i", "+", "1", "]", ")", "return", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "2", ";", "++", "i", ")", "{", "unsigned", "e", "=", "ipar", "[", "i", "*", "nelt2", "]", ";", "if", "(", "e", "%", "nelt2", ")", "return", "0", ";", "e", "/=", "nelt2", ";", "mask", "|=", "e", "<<", "(", "i", "*", "4", ")", ";", "}", "return", "mask", "+", "1", ";", "}", "</s>" ]

[ "Helper", "for", "avx_vperm2f128_v4df_operand", "et", "al", ".", "This", "is", "also", "used", "by", "the", "expansion", "functions", "to", "turn", "the", "parallel", "back", "into", "a", "mask", ".", "The", "return", "value", "is", "0", "for", "no", "match", "and", "the", "imm8+1", "for", "a", "match", "." ]

[ "i386", "2", "0", "8", "0", "0", "0", "0", "0", "2", "0", "0", "1", "1", "1", "0", "1", "1", "1", "0", "0", "2", "0", "4", "1" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasByValOrInAllocaAttr", "(", ")", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "4", ">", "SplitRegs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "SplitRegs", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "ArgInfos", ",", "MF", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "SplitRegs", ".", "push_back", "(", "Reg", ")", ";", "}", ")", ";", "if", "(", "!", "SplitRegs", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "buildMerge", "(", "VRegs", "[", "Idx", "]", ",", "SplitRegs", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "4", "0" ]

[]

[ "<s>", "bool", "XCoreDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Reg", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "true", ";", "case", "XCoreISD", "::", "CPRelativeWrapper", ":", "Reg", "=", "CurDAG", "->", "getRegister", "(", "XCore", "::", "CP", ",", "MVT", "::", "i32", ")", ";", "break", ";", "case", "XCoreISD", "::", "DPRelativeWrapper", ":", "Reg", "=", "CurDAG", "->", "getRegister", "(", "XCore", "::", "DP", ",", "MVT", "::", "i32", ")", ";", "break", ";", "}", "}", "OutOps", ".", "push_back", "(", "Reg", ")", ";", "OutOps", ".", "push_back", "(", "Op", ".", "getOperand", "(", "0", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCoreISD::CPRelativeWrapper", "XCore::CP", "MVT::i32", "XCoreISD::DPRelativeWrapper", "XCore::DP", "MVT::i32", "0" ]

[]

[ "<s>", "static", "int", "arc_restore_callee_saves", "(", "uint64_t", "gmask", ",", "bool", "restore_blink", ",", "bool", "restore_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "allocated", ")", "{", "rtx", "reg", ";", "int", "frame_deallocated", "=", "0", ";", "HOST_WIDE_INT", "offs", "=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "unsigned", "int", "fn_type", "=", "arc_compute_function_type", "(", "cfun", ")", ";", "bool", "early_blink_restore", ";", "int", "i", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "offset", ")", "{", "frame_move", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "if", "(", "restore_fp", ")", "{", "gcc_assert", "(", "offset", "==", "0", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "hard_frame_pointer_rtx", ",", "0", ")", ";", "}", "if", "(", "offset", ")", "{", "frame_stack_add", "(", "offset", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "early_blink_restore", "=", "restore_blink", "&&", "!", "optimize_size", "&&", "offs", "&&", "!", "ARC_INTERRUPT_P", "(", "fn_type", ")", ";", "if", "(", "early_blink_restore", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offs", ")", ";", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "insn", "=", "frame_move_inc", "(", "reg", ",", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "stack_pointer_rtx", ",", "NULL_RTX", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "restore_blink", "=", "false", ";", "}", "if", "(", "gmask", ")", "for", "(", "i", "=", "0", ";", "i", "<=", "GMASK_LEN", ";", "i", "++", ")", "{", "machine_mode", "restore_mode", "=", "SImode", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "i", "%", "2", ")", "==", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1ULL", "<<", "i", ")", ")", "!=", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1ULL", "<<", "(", "i", "+", "1", ")", ")", ")", "!=", "0", ")", ")", "restore_mode", "=", "DImode", ";", "else", "if", "(", "(", "gmask", "&", "(", "1ULL", "<<", "i", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "restore_mode", ",", "i", ")", ";", "offs", "=", "0", ";", "switch", "(", "restore_mode", ")", "{", "case", "E_DImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clzll", "(", "gmask", ")", ")", "==", "(", "i", "+", "1", ")", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clzll", "(", "gmask", ")", ")", "==", "i", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "default", ":", "offs", "=", "0", ";", "}", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "offs", ")", ";", "offset", "=", "0", ";", "if", "(", "restore_mode", "==", "DImode", ")", "i", "++", ";", "}", "if", "(", "restore_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "allocated", "-", "frame_deallocated", "-", "UNITS_PER_WORD", ")", ";", "}", "return", "frame_deallocated", ";", "}", "</s>" ]

[ "ARC", "'s", "epilogue", ",", "restore", "any", "required", "call-saved", "regs", "(", "and", "call-used", "if", "it", "is", "for", "an", "interrupt", "handler", ")", "using", "LD/LDD", "instructions", "." ]

[ "arc", "0", "0", "0", "0", "0", "0", "2", "0", "1ULL", "0", "1ULL", "1", "0", "1ULL", "0", "0", "1", "4", "4", "0", "0" ]

[]

[ "<s>", "LLVM_DUMP_METHOD", "void", "dump", "(", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "dbgs", "(", ")", "<<", "\"Registers: \"", ";", "bool", "First", "=", "true", ";", "for", "(", "unsigned", "Reg", ":", "Edges", ")", "{", "if", "(", "!", "First", ")", "dbgs", "(", ")", "<<", "\", \"", ";", "First", "=", "false", ";", "dbgs", "(", ")", "<<", "printReg", "(", "Reg", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", "<<", "\"Instructions:\"", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Instrs", ")", "{", "dbgs", "(", ")", "<<", "\"\\n \"", ";", "MI", "->", "print", "(", "dbgs", "(", ")", ")", ";", "}", "dbgs", "(", ")", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "X86", "\"Registers: \"", "\", \"", "\"\\n\"", "\"Instructions:\"", "\"\\n \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "HSAILAlwaysInline", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "std", "::", "vector", "<", "Function", "*", ">", "FuncsToClone", ";", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Function", "&", "F", "=", "*", "I", ";", "if", "(", "!", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "isDeclaration", "(", ")", "&&", "!", "F", ".", "use_empty", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "FuncsToClone", ".", "push_back", "(", "&", "F", ")", ";", "}", "for", "(", "Function", "*", "F", ":", "FuncsToClone", ")", "{", "ValueToValueMapTy", "VMap", ";", "Function", "*", "NewFunc", "=", "CloneFunction", "(", "F", ",", "VMap", ",", "false", ")", ";", "NewFunc", "->", "setLinkage", "(", "GlobalValue", "::", "InternalLinkage", ")", ";", "F", "->", "getParent", "(", ")", "->", "getFunctionList", "(", ")", ".", "push_back", "(", "NewFunc", ")", ";", "F", "->", "replaceAllUsesWith", "(", "NewFunc", ")", ";", "}", "for", "(", "Module", "::", "iterator", "I", "=", "M", ".", "begin", "(", ")", ",", "E", "=", "M", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Function", "&", "F", "=", "*", "I", ";", "if", "(", "F", ".", "hasLocalLinkage", "(", ")", "&&", "!", "F", ".", "hasFnAttribute", "(", "Attribute", "::", "NoInline", ")", ")", "{", "F", ".", "addFnAttr", "(", "Attribute", "::", "AlwaysInline", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "mode_suffix_index", "function_resolver", "::", "resolve_sv_displacement", "(", "unsigned", "int", "argno", ",", "type_suffix_index", "type", ",", "bool", "load_p", ")", "{", "if", "(", "type", "==", "NUM_TYPE_SUFFIXES", ")", "{", "vector_type_index", "displacement_vector_type", "=", "infer_vector_displacement_type", "(", "argno", ")", ";", "if", "(", "displacement_vector_type", "==", "NUM_VECTOR_TYPES", ")", "return", "MODE_none", ";", "mode_suffix_index", "mode", "=", "find_mode_suffix", "(", "NUM_VECTOR_TYPES", ",", "displacement_vector_type", ",", "displacement_units", "(", ")", ")", ";", "gcc_assert", "(", "mode", "!=", "MODE_none", ")", ";", "return", "mode", ";", "}", "unsigned", "int", "required_bits", "=", "type_suffixes", "[", "type", "]", ".", "element_bits", ";", "if", "(", "required_bits", "==", "32", "&&", "displacement_units", "(", ")", "==", "UNITS_elements", "&&", "!", "lookup_form", "(", "MODE_s32index", ",", "type", ")", "&&", "!", "lookup_form", "(", "MODE_u32index", ",", "type", ")", ")", "{", "if", "(", "lookup_form", "(", "MODE_u32base_index", ",", "type", ")", ")", "{", "if", "(", "type_suffix_ids", "[", "0", "]", "==", "NUM_TYPE_SUFFIXES", ")", "{", "gcc_assert", "(", "!", "load_p", ")", ";", "error_at", "(", "location", ",", "\"when storing %qT, %qE requires a vector\"", "\" base and a scalar index\"", ",", "get_vector_type", "(", "type", ")", ",", "fndecl", ")", ";", "}", "else", "error_at", "(", "location", ",", "\"%qE requires a vector base and a scalar\"", "\" index\"", ",", "fndecl", ")", ";", "}", "else", "error_at", "(", "location", ",", "\"%qE does not support 32-bit vector type %qT\"", ",", "fndecl", ",", "get_vector_type", "(", "type", ")", ")", ";", "return", "MODE_none", ";", "}", "type_suffix_index", "displacement_type", "=", "infer_vector_type", "(", "argno", ")", ";", "if", "(", "displacement_type", "==", "NUM_TYPE_SUFFIXES", ")", "return", "MODE_none", ";", "if", "(", "type_suffixes", "[", "displacement_type", "]", ".", "element_bits", "==", "required_bits", ")", "{", "vector_type_index", "displacement_vector_type", "=", "type_suffixes", "[", "displacement_type", "]", ".", "vector_type", ";", "mode_suffix_index", "mode", "=", "find_mode_suffix", "(", "NUM_VECTOR_TYPES", ",", "displacement_vector_type", ",", "displacement_units", "(", ")", ")", ";", "if", "(", "mode", "!=", "MODE_none", ")", "{", "if", "(", "mode", "==", "MODE_s32offset", "&&", "!", "lookup_form", "(", "mode", ",", "type", ")", "&&", "lookup_form", "(", "MODE_u32offset", ",", "type", ")", ")", "{", "if", "(", "type_suffix_ids", "[", "0", "]", "==", "NUM_TYPE_SUFFIXES", ")", "error_at", "(", "location", ",", "\"%qE does not support 32-bit sign-extended\"", "\" offsets\"", ",", "fndecl", ")", ";", "else", "error_at", "(", "location", ",", "\"%qE does not support sign-extended\"", "\" offsets\"", ",", "fndecl", ")", ";", "return", "MODE_none", ";", "}", "return", "mode", ";", "}", "}", "if", "(", "type_suffix_ids", "[", "0", "]", "==", "NUM_TYPE_SUFFIXES", ")", "{", "if", "(", "load_p", ")", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which when\"", "\" loading %qT expects a vector of %d-bit integers\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ",", "get_vector_type", "(", "type", ")", ",", "required_bits", ")", ";", "else", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which when\"", "\" storing %qT expects a vector of %d-bit integers\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ",", "get_vector_type", "(", "type", ")", ",", "required_bits", ")", ";", "}", "else", "error_at", "(", "location", ",", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of %d-bit integers\"", ",", "get_argument_type", "(", "argno", ")", ",", "argno", "+", "1", ",", "fndecl", ",", "required_bits", ")", ";", "return", "MODE_none", ";", "}", "</s>" ]

[ "Require", "argument", "ARGNO", "to", "be", "a", "vector", "displacement", "in", "a", "gather-style", "address", ".", "There", "are", "three", "possible", "uses", ":", "-", "for", "loading", "into", "elements", "of", "type", "TYPE", "(", "when", "LOAD_P", "is", "true", ")", "-", "for", "storing", "from", "elements", "of", "type", "TYPE", "(", "when", "LOAD_P", "is", "false", ")", "-", "for", "prefetching", "data", "(", "when", "TYPE", "is", "NUM_TYPE_SUFFIXES", ")", "The", "overloaded", "function", "'s", "mode", "suffix", "determines", "the", "units", "of", "the", "displacement", "(", "bytes", "for", "``", "_offset", "''", ",", "elements", "for", "``", "_index", "''", ")", ".", "Return", "the", "associated", "mode", "on", "success", ",", "otherwise", "report", "an", "error", "and", "return", "MODE_none", "." ]

[ "aarch64", "32", "0", "\"when storing %qT, %qE requires a vector\"", "\" base and a scalar index\"", "\"%qE requires a vector base and a scalar\"", "\" index\"", "\"%qE does not support 32-bit vector type %qT\"", "0", "\"%qE does not support 32-bit sign-extended\"", "\" offsets\"", "\"%qE does not support sign-extended\"", "\" offsets\"", "0", "\"passing %qT to argument %d of %qE, which when\"", "\" loading %qT expects a vector of %d-bit integers\"", "1", "\"passing %qT to argument %d of %qE, which when\"", "\" storing %qT expects a vector of %d-bit integers\"", "1", "\"passing %qT to argument %d of %qE, which\"", "\" expects a vector of %d-bit integers\"", "1" ]

[]

[ "<s>", "LoadInst", "*", "X86TargetLowering", "::", "lowerIdempotentRMWIntoFencedLoad", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "NativeWidth", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "nullptr", ";", "auto", "Builder", "=", "IRBuilder", "<", ">", "(", "AI", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "SSID", "=", "AI", "->", "getSyncScopeID", "(", ")", ";", "auto", "Order", "=", "AtomicCmpXchgInst", "::", "getStrongestFailureOrdering", "(", "AI", "->", "getOrdering", "(", ")", ")", ";", "auto", "Ptr", "=", "AI", "->", "getPointerOperand", "(", ")", ";", "if", "(", "SSID", "==", "SyncScope", "::", "SingleThread", ")", "return", "nullptr", ";", "if", "(", "!", "Subtarget", ".", "hasMFence", "(", ")", ")", "return", "nullptr", ";", "Function", "*", "MFence", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "x86_sse2_mfence", ")", ";", "Builder", ".", "CreateCall", "(", "MFence", ",", "{", "}", ")", ";", "LoadInst", "*", "Loaded", "=", "Builder", ".", "CreateAlignedLoad", "(", "Ptr", ",", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ")", ";", "Loaded", "->", "setAtomic", "(", "Order", ",", "SSID", ")", ";", "AI", "->", "replaceAllUsesWith", "(", "Loaded", ")", ";", "AI", "->", "eraseFromParent", "(", ")", ";", "return", "Loaded", ";", "}", "</s>" ]

[ "On", "some", "platforms", ",", "an", "AtomicRMW", "that", "never", "actually", "modifies", "the", "value", "(", "such", "as", "fetch_add", "of", "0", ")", "can", "be", "turned", "into", "a", "fence", "followed", "by", "an", "atomic", "load", "." ]

[ "X86", "X86", "64", "32", "Intrinsic::getDeclaration", "Intrinsic::x86_sse2_mfence" ]

[]

[ "<s>", "HOST_WIDE_INT", "compute_frame_size", "(", "HOST_WIDE_INT", "size", ",", "int", "*", "fregs_live", ")", "{", "int", "freg_saved", "=", "0", ";", "int", "i", ",", "j", ";", "size", "=", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "&", "~", "(", "UNITS_PER_WORD", "-", "1", ")", ";", "if", "(", "size", "||", "frame_pointer_needed", ")", "size", "+=", "STARTING_FRAME_OFFSET", ";", "if", "(", "DO_FRAME_NOTES", "&&", "current_function_calls_eh_return", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "++", "i", ")", "continue", ";", "size", "+=", "i", "*", "UNITS_PER_WORD", ";", "}", "for", "(", "i", "=", "18", ",", "j", "=", "frame_pointer_needed", "?", "4", ":", "3", ";", "i", ">=", "j", ";", "i", "--", ")", "if", "(", "regs_ever_live", "[", "i", "]", ")", "size", "+=", "UNITS_PER_WORD", ";", "for", "(", "i", "=", "FP_SAVED_REG_LAST", ";", "i", ">=", "FP_SAVED_REG_FIRST", ";", "i", "-=", "FP_REG_STEP", ")", "if", "(", "regs_ever_live", "[", "i", "]", "||", "(", "!", "TARGET_64BIT", "&&", "regs_ever_live", "[", "i", "+", "1", "]", ")", ")", "{", "freg_saved", "=", "1", ";", "size", "+=", "8", ";", "}", "if", "(", "freg_saved", ")", "{", "size", "=", "(", "size", "+", "7", ")", "&", "~", "7", ";", "if", "(", "fregs_live", ")", "*", "fregs_live", "=", "1", ";", "}", "size", "+=", "current_function_outgoing_args_size", ";", "if", "(", "!", "current_function_is_leaf", "||", "size", ")", "size", "+=", "TARGET_64BIT", "?", "48", ":", "32", ";", "return", "(", "(", "size", "+", "PREFERRED_STACK_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", "&", "~", "(", "PREFERRED_STACK_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", ")", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "pa", "0", "1", "1", "0", "18", "4", "3", "1", "1", "8", "7", "7", "1", "48", "32", "1", "1" ]

[]

[ "<s>", "void", "MSP430InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "Desc", ".", "TSFlags", "&", "MSP430TSFlags", "::", "RptCount", ")", "printRptDirective", "(", "MI", ",", "O", ")", ";", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "Address", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430TSFlags::RptCount" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "shouldScheduleLoadsNear", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "Offset1", ",", "int64_t", "Offset2", ",", "unsigned", "NumLoads", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "assert", "(", "Offset2", ">", "Offset1", ")", ";", "if", "(", "(", "Offset2", "-", "Offset1", ")", "/", "8", ">", "64", ")", "return", "false", ";", "if", "(", "Load1", "->", "getMachineOpcode", "(", ")", "!=", "Load2", "->", "getMachineOpcode", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">=", "3", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "shouldScheduleLoadsNear", "-", "This", "is", "a", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "(", "in", "conjunction", "with", "areLoadsFromSameBasePtr", ")", "if", "two", "loads", "should", "be", "scheduled", "togther", "." ]

[ "ARM", "ARM", "8", "64", "3" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DstReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "}", "unsigned", "Opc", ";", "bool", "IsScalableVector", "=", "false", ";", "if", "(", "RISCV", "::", "FPR16RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_H", ";", "else", "if", "(", "RISCV", "::", "FPR32RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_S", ";", "else", "if", "(", "RISCV", "::", "FPR64RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "Opc", "=", "RISCV", "::", "FSGNJ_D", ";", "else", "if", "(", "RISCV", "::", "VRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "RISCV", "::", "PseudoVMV1R_V", ";", "IsScalableVector", "=", "true", ";", "}", "else", "if", "(", "RISCV", "::", "VRM2RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "RISCV", "::", "PseudoVMV2R_V", ";", "IsScalableVector", "=", "true", ";", "}", "else", "if", "(", "RISCV", "::", "VRM4RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "RISCV", "::", "PseudoVMV4R_V", ";", "IsScalableVector", "=", "true", ";", "}", "else", "if", "(", "RISCV", "::", "VRM8RegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", ")", "{", "Opc", "=", "RISCV", "::", "PseudoVMV8R_V", ";", "IsScalableVector", "=", "true", ";", "}", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "if", "(", "IsScalableVector", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "RISCV::GPRRegClass", "RISCV::ADDI", "0", "RISCV::FPR16RegClass", "RISCV::FSGNJ_H", "RISCV::FPR32RegClass", "RISCV::FSGNJ_S", "RISCV::FPR64RegClass", "RISCV::FSGNJ_D", "RISCV::VRRegClass", "RISCV::PseudoVMV1R_V", "RISCV::VRM2RegClass", "RISCV::PseudoVMV2R_V", "RISCV::VRM4RegClass", "RISCV::PseudoVMV4R_V", "RISCV::VRM8RegClass", "RISCV::PseudoVMV8R_V", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "static", "void", "s390_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "if", "(", "DECL_ALIGN", "(", "decl", ")", "%", "64", ")", "SYMBOL_FLAG_SET_NOTALIGN8", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "if", "(", "DECL_ALIGN", "(", "decl", ")", "%", "32", ")", "SYMBOL_FLAG_SET_NOTALIGN4", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "if", "(", "DECL_ALIGN", "(", "decl", ")", "==", "0", "||", "DECL_ALIGN", "(", "decl", ")", "%", "16", ")", "SYMBOL_FLAG_SET_NOTALIGN2", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "}", "if", "(", "MEM_P", "(", "rtl", ")", "&&", "GET_CODE", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "TREE_CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "&&", "MEM_ALIGN", "(", "rtl", ")", "!=", "0", "&&", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "rtl", ")", ")", "!=", "0", ")", "{", "if", "(", "MEM_ALIGN", "(", "rtl", ")", "%", "64", ")", "SYMBOL_FLAG_SET_NOTALIGN8", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "if", "(", "MEM_ALIGN", "(", "rtl", ")", "%", "32", ")", "SYMBOL_FLAG_SET_NOTALIGN4", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "if", "(", "MEM_ALIGN", "(", "rtl", ")", "==", "0", "||", "MEM_ALIGN", "(", "rtl", ")", "%", "16", ")", "SYMBOL_FLAG_SET_NOTALIGN2", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "}", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "(", "local", "vs.", "global", ",", "tls", "model", ")", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

[ "s390", "64", "0", "32", "0", "0", "16", "0", "0", "0", "0", "0", "64", "0", "32", "0", "0", "16", "0" ]

[]

[ "<s>", "unsigned", "AArch64TTIImpl", "::", "getPrefetchDistance", "(", ")", "{", "return", "ST", "->", "getPrefetchDistance", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "int", "s390_cannot_change_mode_class", "(", "machine_mode", "from_mode", ",", "machine_mode", "to_mode", ",", "enum", "reg_class", "rclass", ")", "{", "machine_mode", "small_mode", ";", "machine_mode", "big_mode", ";", "if", "(", "GET_MODE_SIZE", "(", "from_mode", ")", "==", "GET_MODE_SIZE", "(", "to_mode", ")", ")", "return", "0", ";", "if", "(", "GET_MODE_SIZE", "(", "from_mode", ")", "<", "GET_MODE_SIZE", "(", "to_mode", ")", ")", "{", "small_mode", "=", "from_mode", ";", "big_mode", "=", "to_mode", ";", "}", "else", "{", "small_mode", "=", "to_mode", ";", "big_mode", "=", "from_mode", ";", "}", "if", "(", "reg_classes_intersect_p", "(", "VEC_REGS", ",", "rclass", ")", "&&", "(", "GET_MODE_SIZE", "(", "small_mode", ")", "<", "8", "||", "s390_class_max_nregs", "(", "VEC_REGS", ",", "big_mode", ")", "==", "1", ")", ")", "return", "1", ";", "if", "(", "reg_classes_intersect_p", "(", "ACCESS_REGS", ",", "rclass", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "changing", "mode", "from", "FROM", "to", "TO", "should", "not", "be", "allowed", "for", "register", "class", "CLASS", "." ]

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

[]

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

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

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

[]

[ "<s>", "MCSection", "*", "GBZ80TargetObjectFile", "::", "getExplicitSectionGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "llvm_unreachable", "(", "\"getExplicitSectionGlobal not yet implemented!\"", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "method", "to", "assign", "a", "section", "to", "globals", "with", "an", "explicit", "section", "specfied", "." ]

[ "GBZ80", "GB", "\"getExplicitSectionGlobal not yet implemented!\"" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "AArch64AsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "!", "TheTriple", ".", "isOSBinFormatELF", "(", ")", ")", "return", "None", ";", "unsigned", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Default", "(", "-", "1u", ")", ";", "if", "(", "Type", "==", "-", "1u", ")", "return", "None", ";", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "1u", "1u" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Fast Tile Register Configure\"", ";", "}", "</s>" ]

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

[ "X86", "\"Fast Tile Register Configure\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "getPreIndexedAddressParts", "(", "SDNode", "*", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Offset", ",", "ISD", "::", "MemIndexedMode", "&", "AM", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "false", ";", "MVT", "VT", ";", "SDValue", "Ptr", ";", "bool", "isSEXTLoad", "=", "false", ";", "if", "(", "LoadSDNode", "*", "LD", "=", "dyn_cast", "<", "LoadSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "LD", "->", "getBasePtr", "(", ")", ";", "VT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "isSEXTLoad", "=", "LD", "->", "getExtensionType", "(", ")", "==", "ISD", "::", "SEXTLOAD", ";", "}", "else", "if", "(", "StoreSDNode", "*", "ST", "=", "dyn_cast", "<", "StoreSDNode", ">", "(", "N", ")", ")", "{", "Ptr", "=", "ST", "->", "getBasePtr", "(", ")", ";", "VT", "=", "ST", "->", "getMemoryVT", "(", ")", ";", "}", "else", "return", "false", ";", "bool", "isInc", ";", "bool", "isLegal", "=", "getIndexedAddressParts", "(", "Ptr", ".", "getNode", "(", ")", ",", "VT", ",", "isSEXTLoad", ",", "Base", ",", "Offset", ",", "isInc", ",", "DAG", ")", ";", "if", "(", "isLegal", ")", "{", "AM", "=", "isInc", "?", "ISD", "::", "PRE_INC", ":", "ISD", "::", "PRE_DEC", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "by", "value", ",", "base", "pointer", "and", "offset", "pointer", "and", "addressing", "mode", "by", "reference", "if", "the", "node", "'s", "address", "can", "be", "legally", "represented", "as", "pre-indexed", "load", "/", "store", "address", "." ]

[ "ARM", "ARM", "ISD::MemIndexedMode", "ISD::SEXTLOAD", "ISD::PRE_INC", "ISD::PRE_DEC" ]

[]

[ "<s>", "unsigned", "VideocoreMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "getVideocoreRegisterNumbering", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "if", "(", "Kind", "==", "MCExpr", "::", "Binary", ")", "{", "Expr", "=", "static_cast", "<", "const", "MCBinaryExpr", "*", ">", "(", "Expr", ")", "->", "getLHS", "(", ")", ";", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "}", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "return", "0", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "Videocore", "32", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "machine_mode", "op_mode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "if", "(", "vmode", "!=", "op_mode", ")", "return", "false", ";", "bool", "testing_p", "=", "!", "target", ";", "if", "(", "TARGET_ALTIVEC", "&&", "testing_p", ")", "return", "true", ";", "if", "(", "op0", ")", "{", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "}", "if", "(", "op1", ")", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "if", "(", "(", "vmode", "==", "V2DFmode", "||", "vmode", "==", "V2DImode", ")", "&&", "VECTOR_MEM_VSX_P", "(", "vmode", ")", ")", "{", "if", "(", "testing_p", ")", "{", "op0", "=", "gen_raw_REG", "(", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "op1", "=", "gen_raw_REG", "(", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "}", "if", "(", "rs6000_expand_vec_perm_const_1", "(", "target", ",", "op0", ",", "op1", ",", "sel", "[", "0", "]", ",", "sel", "[", "1", "]", ")", ")", "return", "true", ";", "}", "if", "(", "TARGET_ALTIVEC", ")", "{", "if", "(", "vmode", "!=", "V16QImode", ")", "return", "false", ";", "if", "(", "altivec_expand_vec_perm_const", "(", "target", ",", "op0", ",", "op1", ",", "sel", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "SDNode", "*", "PPCDAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "if", "(", "!", "GlobalBaseReg", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "TM", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "if", "(", "PPCLowering", ".", "getPointerTy", "(", ")", "==", "MVT", "::", "i32", ")", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "PPC", "::", "GPRCRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR", ")", ",", "PPC", "::", "LR", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR", ")", ",", "GlobalBaseReg", ")", ";", "}", "else", "{", "GlobalBaseReg", "=", "RegInfo", "->", "createVirtualRegister", "(", "PPC", "::", "G8RCRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MovePCtoLR8", ")", ",", "PPC", "::", "LR8", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFLR8", ")", ",", "GlobalBaseReg", ")", ";", "}", "}", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "PPCLowering", ".", "getPointerTy", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "MVT::i32", "PPC::GPRCRegisterClass", "PPC::MovePCtoLR", "PPC::LR", "PPC::MFLR", "PPC::G8RCRegisterClass", "PPC::MovePCtoLR8", "PPC::LR8", "PPC::MFLR8", "PPC" ]

[]

[ "<s>", "SDValue", "AVRTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "auto", "CCFunction", "=", "CCAssignFnForReturn", "(", "CallConv", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "CCFunction", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "if", "(", "e", ">", "1", ")", "{", "std", "::", "reverse", "(", "RVLocs", ".", "begin", "(", ")", ",", "RVLocs", ".", "end", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "Naked", ")", ")", "{", "return", "Chain", ";", "}", "unsigned", "RetOpc", "=", "(", "CallConv", "==", "CallingConv", "::", "AVR_INTR", "||", "CallConv", "==", "CallingConv", "::", "AVR_SIGNAL", ")", "?", "AVRISD", "::", "RETI_FLAG", ":", "AVRISD", "::", "RET_FLAG", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "RetOpc", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "ISD::OutputArg", "16", "1", "4", "1", "0", "\"Can only return in registers!\"", "1", "AVR", "AVR", "AVRISD::RETI_FLAG", "AVRISD::RET_FLAG", "0", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "sparc_use_pseudo_pic_reg", "(", "void", ")", "{", "return", "!", "TARGET_VXWORKS_RTP", "&&", "flag_pic", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_PSEUDO_PIC_REG", "." ]

[ "sparc" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "new", "CoalesceFeaturesAndStripAtomics", "(", "&", "getWebAssemblyTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyAddMissingPrototypes", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerGlobalDtors", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "if", "(", "!", "EnableEmException", "&&", "TM", "->", "Options", ".", "ExceptionModel", "==", "ExceptionHandling", "::", "None", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "EnableEmException", "||", "EnableEmSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", "EnableEmException", ",", "EnableEmSjLj", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", "==", "MVT", "::", "f16", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "!", "Subtarget", ".", "hasStdExtZfhmin", "(", ")", ")", "return", "1", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "RISCV", "RISCV", "MVT::f16", "1" ]

[]

[ "<s>", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "ArrayRef", "<", "unsigned", ">", "Ops", ",", "MachineBasicBlock", "::", "iterator", "InsertPt", ",", "MachineInstr", "*", "LoadMI", ")", "const", "override", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Hexagon" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "MBlaze" ]

[]