Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerCall", "(", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "const", "Function", "&", "Fn", "=", "*", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "StringRef", "FuncName", "(", "\"<unknown>\"", ")", ";", "if", "(", "const", "ExternalSymbolSDNode", "*", "G", "=", "dyn_cast", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getSymbol", "(", ")", ";", "else", "if", "(", "const", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "FuncName", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "DiagnosticInfoUnsupported", "NoCalls", "(", "Fn", ",", "\"unsupported call to function \"", "+", "FuncName", ",", "CLI", ".", "DL", ".", "getDebugLoc", "(", ")", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "NoCalls", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "CLI", ".", "Ins", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "InVals", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "CLI", ".", "Ins", "[", "I", "]", ".", "VT", ")", ")", ";", "return", "DAG", ".", "getEntryNode", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"<unknown>\"", "\"unsupported call to function \"", "0" ]

[]

[ "<s>", "int", "romp_pushes_stack", "(", ")", "{", "return", "(", "frame_pointer_needed", "||", "write_symbols", "!=", "NO_DEBUG", "||", "(", "romp_sa_size", "(", ")", "+", "get_frame_size", "(", ")", ")", ">", "100", "||", "romp_makes_calls", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "needs", "to", "push", "space", "on", "the", "stack", "." ]

[ "romp", "100" ]

[]

[ "<s>", "void", "ix86_expand_binary_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "src1", ",", "src2", ",", "dst", ",", "op", ",", "clob", ";", "dst", "=", "ix86_fixup_binary_operands", "(", "code", ",", "mode", ",", "operands", ")", ";", "src1", "=", "operands", "[", "1", "]", ";", "src2", "=", "operands", "[", "2", "]", ";", "op", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dst", ",", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "src1", ",", "src2", ")", ")", ";", "if", "(", "reload_in_progress", ")", "{", "gcc_assert", "(", "code", "==", "PLUS", ")", ";", "emit_insn", "(", "op", ")", ";", "}", "else", "if", "(", "reload_completed", "&&", "code", "==", "PLUS", "&&", "!", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "{", "emit_insn", "(", "op", ")", ";", "}", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "op", ",", "clob", ")", ")", ")", ";", "}", "if", "(", "dst", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "dst", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "expand", "a", "binary", "operator", ".", "Make", "the", "expansion", "closer", "to", "the", "actual", "machine", ",", "then", "just", "general_operand", ",", "which", "will", "allow", "3", "separate", "memory", "references", "(", "one", "output", ",", "two", "input", ")", "in", "a", "single", "insn", "." ]

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

[]

[ "<s>", "static", "const", "char", "*", "output_branch", "(", "rtx", "label", ",", "const", "char", "*", "cond", ",", "rtx_insn", "*", "insn", ")", "{", "char", "str", "[", "64", "]", ";", "rtx", "operands", "[", "2", "]", ";", "gcc_assert", "(", "cond", ")", ";", "operands", "[", "0", "]", "=", "label", ";", "if", "(", "get_attr_length", "(", "insn", ")", ">", "8", ")", "{", "bool", "spilled", ";", "if", "(", "current_function_saves_lr", "(", ")", ")", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "LINK_REGNUM", "]", ";", "spilled", "=", "false", ";", "}", "else", "if", "(", "!", "df_regs_ever_live_p", "(", "long_branch_regnum", ")", ")", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "long_branch_regnum", "]", ";", "spilled", "=", "false", ";", "}", "else", "{", "operands", "[", "1", "]", "=", "regno_reg_rtx", "[", "long_branch_regnum", "]", ";", "spilled", "=", "true", ";", "gcc_assert", "(", "current_function_has_lr_slot", "(", ")", ")", ";", "}", "if", "(", "spilled", ")", "{", "if", "(", "final_sequence", ")", "{", "rtx_insn", "*", "delay", "=", "NEXT_INSN", "(", "insn", ")", ";", "int", "seen", ";", "gcc_assert", "(", "delay", ")", ";", "final_scan_insn", "(", "delay", ",", "asm_out_file", ",", "optimize", ",", "0", ",", "&", "seen", ")", ";", "PATTERN", "(", "delay", ")", "=", "gen_blockage", "(", ")", ";", "INSN_CODE", "(", "delay", ")", "=", "-", "1", ";", "}", "if", "(", "current_function_saves_fp", "(", ")", ")", "output_asm_insn", "(", "\"write.l 1(sp),%1\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\"write.l (sp),%1\"", ",", "operands", ")", ";", "}", "output_asm_insn", "(", "\"moviu %1,%%u %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"movil %1,%%l %0\"", ",", "operands", ")", ";", "strcpy", "(", "str", ",", "\"bra \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",%1,%1\"", ")", ";", "if", "(", "!", "spilled", ")", "strcat", "(", "str", ",", "\"%#\"", ")", ";", "strcat", "(", "str", ",", "\"\\t\\t;long branch\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "if", "(", "spilled", ")", "{", "if", "(", "current_function_saves_fp", "(", ")", ")", "output_asm_insn", "(", "\" read.l %1,1(sp)\"", ",", "operands", ")", ";", "else", "output_asm_insn", "(", "\" read.l %1,(sp)\"", ",", "operands", ")", ";", "}", "}", "else", "if", "(", "label", "==", "pc_rtx", ")", "{", "strcpy", "(", "str", ",", "\"bra \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",r21,r0%#\\t\\t;return\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "}", "else", "{", "strcpy", "(", "str", ",", "\"brr \"", ")", ";", "strcat", "(", "str", ",", "cond", ")", ";", "strcat", "(", "str", ",", "\",%0%#\"", ")", ";", "output_asm_insn", "(", "str", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "conditional/unconditional", "branch", "to", "LABEL", ".", "COND", "is", "the", "string", "condition", ".", "INSN", "is", "the", "instruction", "." ]

[ "visium", "64", "2", "0", "8", "1", "1", "1", "0", "1", "\"write.l 1(sp),%1\"", "\"write.l (sp),%1\"", "\"moviu %1,%%u %0\"", "\"movil %1,%%l %0\"", "\"bra \"", "\",%1,%1\"", "\"%#\"", "\"\\t\\t;long branch\"", "\" read.l %1,1(sp)\"", "\" read.l %1,(sp)\"", "\"bra \"", "\",r21,r0%#\\t\\t;return\"", "\"brr \"", "\",%0%#\"", "\"\"" ]

[]

[ "<s>", "bool", "PIC16AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "CurrentFnName", "=", "Mang", "->", "getMangledName", "(", "F", ")", ";", "EmitFunctionFrame", "(", "MF", ")", ";", "DbgInfo", ".", "BeginFunction", "(", "MF", ")", ";", "EmitAutos", "(", "CurrentFnName", ")", ";", "const", "MCSection", "*", "fCodeSection", "=", "getObjFileLowering", "(", ")", ".", "getSectionForFunction", "(", "CurrentFnName", ")", ";", "O", "<<", "\"\\n\"", ";", "OutStreamer", ".", "SwitchSection", "(", "fCodeSection", ")", ";", "O", "<<", "\"\\tretlw low(\"", "<<", "PAN", "::", "getFrameLabel", "(", "CurrentFnName", ")", "<<", "\")\\n\"", ";", "O", "<<", "\"\\tretlw high(\"", "<<", "PAN", "::", "getFrameLabel", "(", "CurrentFnName", ")", "<<", "\")\\n\"", ";", "O", "<<", "CurrentFnName", "<<", "\":\\n\"", ";", "DebugLoc", "CurDL", ";", "O", "<<", "\"\\n\"", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "const", "DebugLoc", "DL", "=", "II", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DL", ".", "isUnknown", "(", ")", "&&", "DL", "!=", "CurDL", ")", "{", "DbgInfo", ".", "ChangeDebugLoc", "(", "MF", ",", "DL", ")", ";", "CurDL", "=", "DL", ";", "}", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "DbgInfo", ".", "EndFunction", "(", "MF", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PIC16", "PIC16", "\"\\n\"", "\"\\tretlw low(\"", "\")\\n\"", "\"\\tretlw high(\"", "\")\\n\"", "\":\\n\"", "\"\\n\"" ]

[]

[ "<s>", "void", "or1k_expand_move", "(", "machine_mode", "mode", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "if", "(", "!", "const0_operand", "(", "op1", ",", "mode", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "}", "else", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "{", "}", "else", "{", "switch", "(", "GET_CODE", "(", "op1", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "!", "input_operand", "(", "op1", ",", "mode", ")", ")", "{", "HOST_WIDE_INT", "i", "=", "INTVAL", "(", "op1", ")", ";", "HOST_WIDE_INT", "lo", "=", "i", "&", "0xffff", ";", "HOST_WIDE_INT", "hi", "=", "i", "^", "lo", ";", "rtx", "subtarget", "=", "op0", ";", "if", "(", "!", "cse_not_expected", "&&", "can_create_pseudo_p", "(", ")", ")", "subtarget", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "subtarget", ",", "GEN_INT", "(", "hi", ")", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "op0", ",", "subtarget", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "return", ";", "}", "break", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "op1", "=", "or1k_legitimize_address_1", "(", "op1", ",", "op0", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "op1", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "patterns", "``", "movqi", "''", ",", "``", "movqi", "''", "and", "``", "movsi", "''", ".", "The", "argument", "OP0", "is", "the", "destination", "and", "OP1", "is", "the", "source", ".", "This", "expands", "to", "set", "OP0", "to", "OP1", ".", "OpenRISC", "can", "not", "do", "memory", "to", "memory", "assignments", "so", "for", "those", "cases", "we", "force", "one", "argument", "to", "a", "register", ".", "Constants", "that", "ca", "n't", "fit", "into", "a", "16-bit", "immediate", "are", "split", ".", "Symbols", "are", "legitimized", "using", "split", "relocations", "." ]

[ "or1k", "0xffff" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "VectorComponents", "=", "0", ";", "if", "(", "(", "R600", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "||", "R600", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "R600", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", "||", "R600", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "4", ";", "}", "else", "if", "(", "(", "R600", "::", "R600_Reg64RegClass", ".", "contains", "(", "DestReg", ")", "||", "R600", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "R600", "::", "R600_Reg64RegClass", ".", "contains", "(", "SrcReg", ")", "||", "R600", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "2", ";", "}", "if", "(", "VectorComponents", ">", "0", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "VectorComponents", ";", "I", "++", ")", "{", "unsigned", "SubRegIndex", "=", "AMDGPURegisterInfo", "::", "getSubRegFromChannel", "(", "I", ")", ";", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "R600", "::", "MOV", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubRegIndex", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SubRegIndex", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "}", "}", "else", "{", "MachineInstr", "*", "NewMI", "=", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "R600", "::", "MOV", ",", "DestReg", ",", "SrcReg", ")", ";", "NewMI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "NewMI", ",", "R600", "::", "OpName", "::", "src0", ")", ")", ".", "setIsKill", "(", "KillSrc", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "0", "R600::R600_Reg128RegClass", "R600::R600_Reg128VerticalRegClass", "R600::R600_Reg128RegClass", "R600::R600_Reg128VerticalRegClass", "4", "R600::R600_Reg64RegClass", "R600::R600_Reg64VerticalRegClass", "R600::R600_Reg64RegClass", "R600::R600_Reg64VerticalRegClass", "2", "0", "0", "AMDGPU", "R600::MOV", "R600::MOV", "R600::OpName" ]

[]

[ "<s>", "void", "X86ATTInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "O", "<<", "formatImm", "(", "Op", ".", "getImm", "(", ")", ")", ";", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "EvaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "formatHex", "(", "(", "uint64_t", ")", "Address", ")", ";", "}", "else", "{", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "\"unknown pcrel immediate operand\"" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "break", ";", "default", ":", "assert", "(", "0", "&&", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "MachineBasicBlock", "::", "iterator", "LastCSPop", "=", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "0", "&&", "\"Not implemented yet!\"", ")", ";", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "0", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FPW", "MSP430::POP16r", "0", "\"Not implemented yet!\"", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "void", "HexagonHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Advance cycle, clear state\\n\"", ")", ";", "Resources", "->", "clearResources", "(", ")", ";", "if", "(", "DotCurPNum", "!=", "-", "1", "&&", "DotCurPNum", "!=", "(", "int", ")", "PacketNum", ")", "{", "UsesDotCur", "=", "nullptr", ";", "DotCurPNum", "=", "-", "1", ";", "}", "PacketNum", "++", ";", "RegDefs", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "Hexagon", "Hexagon", "\"Advance cycle, clear state\\n\"", "1", "1" ]

[]

[ "<s>", "static", "rtx", "cris_function_arg", "(", "cumulative_args_t", "ca", ",", "const", "function_arg_info", "&", "arg", ")", "{", "return", "cris_function_arg_1", "(", "ca", ",", "arg", ",", "false", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_FUNCTION_ARG", ".", "The", "void_type_node", "is", "sent", "as", "a", "``", "closing", "''", "call", "." ]

[ "cris" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DstReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "assert", "(", "RISCV", "::", "GPRRegClass", ".", "contains", "(", "DstReg", ",", "SrcReg", ")", "&&", "\"Impossible reg-to-reg copy\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "RISCV", "::", "ADDI", ")", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::GPRRegClass", "\"Impossible reg-to-reg copy\"", "RISCV::ADDI", "0" ]

[]

[ "<s>", "bool", "MMIXAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX" ]

[]

[ "<s>", "const", "MCExpr", "*", "AMDGPUAsmPrinter", "::", "lowerConstant", "(", "const", "Constant", "*", "CV", ")", "{", "auto", "*", "AT", "=", "static_cast", "<", "AMDGPUTargetMachine", "*", ">", "(", "&", "TM", ")", ";", "auto", "*", "CE", "=", "dyn_cast", "<", "ConstantExpr", ">", "(", "CV", ")", ";", "if", "(", "CE", "&&", "CE", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "AddrSpaceCast", ")", "{", "auto", "Op", "=", "CE", "->", "getOperand", "(", "0", ")", ";", "auto", "SrcAddr", "=", "Op", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "if", "(", "Op", "->", "isNullValue", "(", ")", "&&", "AT", "->", "getNullPointerValue", "(", "SrcAddr", ")", "==", "0", ")", "{", "auto", "DstAddr", "=", "CE", "->", "getType", "(", ")", "->", "getPointerAddressSpace", "(", ")", ";", "return", "MCConstantExpr", "::", "create", "(", "AT", "->", "getNullPointerValue", "(", "DstAddr", ")", ",", "OutContext", ")", ";", "}", "}", "return", "AsmPrinter", "::", "lowerConstant", "(", "CV", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MSP430InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "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" ]

[]

[ "<s>", "const", "char", "*", "output_lbranch", "(", "rtx", "dest", ",", "rtx", "insn", ")", "{", "rtx", "xoperands", "[", "2", "]", ";", "xoperands", "[", "0", "]", "=", "dest", ";", "if", "(", "dbr_sequence_length", "(", ")", "!=", "0", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "NEXT_INSN", "(", "insn", ")", ")", "!=", "JUMP_INSN", ")", ";", "final_scan_insn", "(", "NEXT_INSN", "(", "insn", ")", ",", "asm_out_file", ",", "optimize", ",", "0", ",", "NULL", ")", ";", "PUT_CODE", "(", "NEXT_INSN", "(", "insn", ")", ",", "NOTE", ")", ";", "NOTE_LINE_NUMBER", "(", "NEXT_INSN", "(", "insn", ")", ")", "=", "NOTE_INSN_DELETED", ";", "NOTE_SOURCE_FILE", "(", "NEXT_INSN", "(", "insn", ")", ")", "=", "0", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "regs_ever_live", "[", "2", "]", ")", "output_asm_insn", "(", "\"std %%r1,-16(%%r30)\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"std %%r1,-40(%%r30)\"", ",", "xoperands", ")", ";", "}", "else", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "regs_ever_live", "[", "2", "]", ")", "output_asm_insn", "(", "\"stw %%r1,-20(%%r30)\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"stw %%r1,-12(%%r30)\"", ",", "xoperands", ")", ";", "}", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0(%%r1),%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "output_asm_insn", "(", "\"{bl|b,l} .+8,%%r1\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_SOM", "||", "!", "TARGET_GAS", ")", "{", "xoperands", "[", "1", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_insn", "(", "\"addil L'%l0-%l1,%%r1\"", ",", "xoperands", ")", ";", "(", "*", "targetm", ".", "asm_out", ".", "internal_label", ")", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "xoperands", "[", "1", "]", ")", ")", ";", "output_asm_insn", "(", "\"ldo R'%l0-%l1(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"addil L'%l0-$PIC_pcrel$0+4,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%l0-$PIC_pcrel$0+8(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "output_asm_insn", "(", "\"ldil L'%l0,%%r1\\n\\tbe R'%l0(%%sr4,%%r1)\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "regs_ever_live", "[", "2", "]", ")", "return", "\"ldd -16(%%r30),%%r1\"", ";", "else", "return", "\"ldd -40(%%r30),%%r1\"", ";", "}", "else", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "regs_ever_live", "[", "2", "]", ")", "return", "\"ldw -20(%%r30),%%r1\"", ";", "else", "return", "\"ldw -12(%%r30),%%r1\"", ";", "}", "}", "</s>" ]

[ "This", "routine", "handles", "long", "unconditional", "branches", "that", "exceed", "the", "maximum", "range", "of", "a", "simple", "branch", "instruction", "." ]

[ "pa", "2", "0", "0", "0", "0", "0", "2", "\"std %%r1,-16(%%r30)\"", "\"std %%r1,-40(%%r30)\"", "0", "2", "\"stw %%r1,-20(%%r30)\"", "\"stw %%r1,-12(%%r30)\"", "\"ldil L'%0,%%r1\"", "\"ldo R'%0(%%r1),%%r1\"", "\"bv %%r0(%%r1)\"", "\"{bl|b,l} .+8,%%r1\"", "1", "\"addil L'%l0-%l1,%%r1\"", "\"L\"", "1", "\"ldo R'%l0-%l1(%%r1),%%r1\"", "\"addil L'%l0-$PIC_pcrel$0+4,%%r1\"", "\"ldo R'%l0-$PIC_pcrel$0+8(%%r1),%%r1\"", "\"bv %%r0(%%r1)\"", "\"ldil L'%l0,%%r1\\n\\tbe R'%l0(%%sr4,%%r1)\"", "0", "2", "\"ldd -16(%%r30),%%r1\"", "\"ldd -40(%%r30),%%r1\"", "0", "2", "\"ldw -20(%%r30),%%r1\"", "\"ldw -12(%%r30),%%r1\"" ]

[]

[ "<s>", "const", "unsigned", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "static", "const", "unsigned", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430", "MSP430" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getGOT", "(", "NodeTy", "*", "N", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flags", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"AArch64TargetLowering::getGOT\\n\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "EVT", "Ty", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "GotAddr", "=", "getTargetNode", "(", "N", ",", "Ty", ",", "DAG", ",", "AArch64II", "::", "MO_GOT", "|", "Flags", ")", ";", "return", "DAG", ".", "getNode", "(", "AArch64ISD", "::", "LOADgot", ",", "DL", ",", "Ty", ",", "GotAddr", ")", ";", "}", "</s>" ]

[ "Return", "a", "pseudo", "source", "value", "referencing", "the", "global", "offset", "table", "(", "or", "something", "the", "like", ")", "." ]

[ "AArch64", "AArch64", "\"AArch64TargetLowering::getGOT\\n\"", "AArch64II::MO_GOT", "AArch64ISD::LOADgot" ]

[]

[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", "->", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]

[ "AArch64" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "ScheduleDAGMILive", "*", "DAG", "=", "createGenericSchedLive", "(", "C", ")", ";", "return", "DAG", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

[ "ARM" ]

[]

[ "<s>", "int", "barrier_align", "(", "rtx_insn", "*", "barrier_or_label", ")", "{", "rtx", "next", ",", "pat", ";", "if", "(", "!", "barrier_or_label", ")", "return", "0", ";", "if", "(", "LABEL_P", "(", "barrier_or_label", ")", "&&", "NEXT_INSN", "(", "barrier_or_label", ")", "&&", "JUMP_TABLE_DATA_P", "(", "NEXT_INSN", "(", "barrier_or_label", ")", ")", ")", "return", "2", ";", "if", "(", "BARRIER_P", "(", "barrier_or_label", ")", "&&", "PREV_INSN", "(", "barrier_or_label", ")", "&&", "JUMP_TABLE_DATA_P", "(", "PREV_INSN", "(", "barrier_or_label", ")", ")", ")", "{", "pat", "=", "PATTERN", "(", "PREV_INSN", "(", "barrier_or_label", ")", ")", ";", "return", "(", "(", "optimize_size", "||", "(", "(", "unsigned", ")", "XVECLEN", "(", "pat", ",", "1", ")", "*", "GET_MODE_SIZE", "(", "GET_MODE", "(", "pat", ")", ")", "<=", "(", "unsigned", ")", "1", "<<", "(", "CACHE_LOG", "-", "2", ")", ")", ")", "?", "1", "<<", "TARGET_SHMEDIA", ":", "align_jumps_log", ")", ";", "}", "next", "=", "next_active_insn", "(", "barrier_or_label", ")", ";", "if", "(", "!", "next", ")", "return", "0", ";", "pat", "=", "PATTERN", "(", "next", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "pat", ",", "1", ")", "==", "UNSPECV_ALIGN", ")", "return", "0", ";", "if", "(", "optimize_size", ")", "return", "0", ";", "if", "(", "!", "TARGET_SH2", "||", "!", "optimize", ")", "return", "align_jumps_log", ";", "if", "(", "mdep_reorg_phase", ">", "SH_FIXUP_PCLOAD", ")", "{", "int", "slot", ",", "credit", ";", "bool", "jump_to_next", "=", "false", ";", "rtx_insn", "*", "prev", "=", "prev_real_insn", "(", "prev_active_insn", "(", "barrier_or_label", ")", ")", ";", "for", "(", "slot", "=", "2", ",", "credit", "=", "(", "1", "<<", "(", "CACHE_LOG", "-", "2", ")", ")", "+", "2", ";", "credit", ">=", "0", "&&", "prev", "&&", "NONJUMP_INSN_P", "(", "prev", ")", ";", "prev", "=", "prev_real_insn", "(", "prev", ")", ")", "{", "jump_to_next", "=", "false", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "USE", "||", "GET_CODE", "(", "PATTERN", "(", "prev", ")", ")", "==", "CLOBBER", ")", "continue", ";", "if", "(", "rtx_sequence", "*", "prev_seq", "=", "dyn_cast", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "prev", ")", ")", ")", "{", "prev", "=", "prev_seq", "->", "insn", "(", "1", ")", ";", "if", "(", "INSN_UID", "(", "prev", ")", "==", "INSN_UID", "(", "next", ")", ")", "{", "jump_to_next", "=", "true", ";", "continue", ";", "}", "}", "if", "(", "slot", "&&", "get_attr_in_delay_slot", "(", "prev", ")", "==", "IN_DELAY_SLOT_YES", ")", "slot", "=", "0", ";", "credit", "-=", "get_attr_length", "(", "prev", ")", ";", "}", "if", "(", "prev", "&&", "jump_to_label_p", "(", "prev", ")", ")", "{", "rtx_insn", "*", "x", ";", "if", "(", "jump_to_next", "||", "next_real_insn", "(", "JUMP_LABEL", "(", "prev", ")", ")", "==", "next", "||", "JUMP_LABEL", "(", "prev", ")", "==", "next_nonnote_insn", "(", "next", ")", "||", "(", "x", "=", "(", "NEXT_INSN", "(", "NEXT_INSN", "(", "PREV_INSN", "(", "prev", ")", ")", ")", ")", ",", "(", "INSN_P", "(", "x", ")", "&&", "(", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_block_branch_redirect", "||", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_indirect_jump_scratch", "||", "INSN_CODE", "(", "x", ")", "==", "CODE_FOR_stuff_delay_slot", ")", ")", ")", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "prev", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "credit", "-", "slot", ">=", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "PC", "?", "2", ":", "0", ")", ")", "return", "0", ";", "}", "}", "}", "return", "align_jumps_log", ";", "}", "</s>" ]

[ "BARRIER_OR_LABEL", "is", "either", "a", "BARRIER", "or", "a", "CODE_LABEL", "immediately", "following", "a", "barrier", ".", "Return", "the", "base", "2", "logarithm", "of", "the", "desired", "alignment", "." ]

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

[]

[ "<s>", "void", "MCS51RegisterInfo", "::", "splitReg", "(", "Register", "Reg", ",", "Register", "&", "LoReg", ",", "Register", "&", "HiReg", ")", "const", "{", "assert", "(", "MCS51", "::", "DREGSRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"can only split 16-bit registers\"", ")", ";", "LoReg", "=", "getSubReg", "(", "Reg", ",", "MCS51", "::", "sub_lo", ")", ";", "HiReg", "=", "getSubReg", "(", "Reg", ",", "MCS51", "::", "sub_hi", ")", ";", "}", "</s>" ]

[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]

[ "MCS51", "MCS51", "MCS51::DREGSRegClass", "\"can only split 16-bit registers\"", "MCS51::sub_lo", "MCS51::sub_hi" ]

[]

[ "<s>", "static", "void", "mcore_setup_incoming_varargs", "(", "cumulative_args_t", "args_so_far_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "ptr_pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "second_time", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "args_so_far", "=", "get_cumulative_args", "(", "args_so_far_v", ")", ";", "current_function_anonymous_args", "=", "1", ";", "number_of_regs_before_varargs", "=", "*", "args_so_far", "+", "mcore_num_arg_regs", "(", "mode", ",", "type", ")", ";", "number_of_regs_before_varargs", "=", "*", "args_so_far", ";", "if", "(", "number_of_regs_before_varargs", ">", "NPARM_REGS", ")", "number_of_regs_before_varargs", "=", "NPARM_REGS", ";", "}", "</s>" ]

[ "Keep", "track", "of", "some", "information", "about", "varargs", "for", "the", "prolog", "." ]

[ "mcore", "1" ]

[]

[ "<s>", "unsigned", "ARMInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDR", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "FLDD", ":", "case", "ARM", "::", "FLDS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "tRestore", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LDR", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::FLDD", "ARM::FLDS", "1", "2", "2", "0", "1", "0", "ARM::tRestore", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "section", "*", "avr_asm_function_rodata_section", "(", "tree", "decl", ")", "{", "unsigned", "int", "flags", ";", "section", "*", "frodata", ";", "{", "int", "fdata", "=", "flag_data_sections", ";", "flag_data_sections", "=", "flag_function_sections", ";", "frodata", "=", "default_function_rodata_section", "(", "decl", ")", ";", "flag_data_sections", "=", "fdata", ";", "flags", "=", "frodata", "->", "common", ".", "flags", ";", "}", "if", "(", "frodata", "!=", "readonly_data_section", "&&", "flags", "&", "SECTION_NAMED", ")", "{", "unsigned", "int", "i", ";", "static", "const", "char", "*", "const", "prefix", "[", "]", "=", "{", "\".rodata\"", ",", "\".progmem.gcc_sw_table\"", ",", "\".gnu.linkonce.r.\"", ",", "\".gnu.linkonce.t.\"", "}", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "(", "prefix", ")", "/", "sizeof", "(", "*", "prefix", ")", ";", "i", "+=", "2", ")", "{", "const", "char", "*", "old_prefix", "=", "prefix", "[", "i", "]", ";", "const", "char", "*", "new_prefix", "=", "prefix", "[", "i", "+", "1", "]", ";", "const", "char", "*", "name", "=", "frodata", "->", "named", ".", "name", ";", "if", "(", "STR_PREFIX_P", "(", "name", ",", "old_prefix", ")", ")", "{", "const", "char", "*", "rname", "=", "ACONCAT", "(", "(", "new_prefix", ",", "name", "+", "strlen", "(", "old_prefix", ")", ",", "NULL", ")", ")", ";", "flags", "&=", "~", "SECTION_CODE", ";", "flags", "|=", "AVR_HAVE_JMP_CALL", "?", "0", ":", "SECTION_CODE", ";", "return", "get_section", "(", "rname", ",", "flags", ",", "frodata", "->", "named", ".", "decl", ")", ";", "}", "}", "}", "return", "progmem_swtable_section", ";", "}", "</s>" ]

[ "Implement", "`", "TARGET_ASM_FUNCTION_RODATA_SECTION", "'", "." ]

[ "avr", "\".rodata\"", "\".progmem.gcc_sw_table\"", "\".gnu.linkonce.r.\"", "\".gnu.linkonce.t.\"", "0", "2", "1", "0" ]

[]

[ "<s>", "static", "rtx", "avr_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "if", "(", "cum", "->", "nregs", "&&", "bytes", "<=", "cum", "->", "nregs", ")", "return", "gen_rtx_REG", "(", "mode", ",", "cum", "->", "regno", "-", "bytes", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Controls", "whether", "a", "function", "argument", "is", "passed", "in", "a", "register", ",", "and", "which", "register", "." ]

[ "avr" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreLegalizeMachineIR", "(", ")", "{", "addPass", "(", "createAArch64PreLegalizeCombiner", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUPromoteAllocaImpl", "::", "run", "(", "Function", "&", "F", ")", "{", "Mod", "=", "F", ".", "getParent", "(", ")", ";", "DL", "=", "&", "Mod", "->", "getDataLayout", "(", ")", ";", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "IsAMDGCN", "=", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ";", "IsAMDHSA", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "AMDGPUSubtarget", "::", "get", "(", "TM", ",", "F", ")", ";", "if", "(", "!", "ST", ".", "isPromoteAllocaEnabled", "(", ")", ")", "return", "false", ";", "if", "(", "IsAMDGCN", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "MaxVGPRs", "=", "ST", ".", "getMaxNumVGPRs", "(", "ST", ".", "getWavesPerEU", "(", "F", ")", ".", "first", ")", ";", "}", "else", "{", "MaxVGPRs", "=", "128", ";", "}", "bool", "SufficientLDS", "=", "hasSufficientLocalMem", "(", "F", ")", ";", "bool", "Changed", "=", "false", ";", "BasicBlock", "&", "EntryBB", "=", "*", "F", ".", "begin", "(", ")", ";", "SmallVector", "<", "AllocaInst", "*", ",", "16", ">", "Allocas", ";", "for", "(", "Instruction", "&", "I", ":", "EntryBB", ")", "{", "if", "(", "AllocaInst", "*", "AI", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "&", "I", ")", ")", "Allocas", ".", "push_back", "(", "AI", ")", ";", "}", "for", "(", "AllocaInst", "*", "AI", ":", "Allocas", ")", "{", "if", "(", "handleAlloca", "(", "*", "AI", ",", "SufficientLDS", ")", ")", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "128", "16" ]

[]

[ "<s>", "bool", "WebAssemblyOptimizeLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "LIS", "=", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "assert", "(", "MRI", ".", "tracksLiveness", "(", ")", "&&", "\"OptimizeLiveIntervals expects liveness\"", ")", ";", "SmallVector", "<", "LiveInterval", "*", ",", "4", ">", "SplitLIs", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", ".", "reg_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "LIS", ".", "splitSeparateComponents", "(", "LIS", ".", "getInterval", "(", "Reg", ")", ",", "SplitLIs", ")", ";", "SplitLIs", ".", "clear", "(", ")", ";", "}", "for", "(", "auto", "MII", "=", "MF", ".", "begin", "(", ")", "->", "begin", "(", ")", ",", "MIE", "=", "MF", ".", "begin", "(", ")", "->", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "*", "MI", "=", "&", "*", "MII", "++", ";", "if", "(", "MI", "->", "isImplicitDef", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "LiveInterval", "&", "LI", "=", "LIS", ".", "getInterval", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ";", "LIS", ".", "removeVRegDefAt", "(", "LI", ",", "LIS", ".", "getInstructionIndex", "(", "*", "MI", ")", ".", "getRegSlot", "(", ")", ")", ";", "LIS", ".", "RemoveMachineInstrFromMaps", "(", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Optimize LiveIntervals **********\\n\"", "\"********** Function: \"", "\"OptimizeLiveIntervals expects liveness\"", "4", "0", "0", "0" ]

[]

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

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

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

[]

[ "<s>", "static", "machine_mode", "sparc_secondary_memory_needed_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_ARCH64", ")", "{", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "32", ")", "return", "mode_for_size", "(", "32", ",", "GET_MODE_CLASS", "(", "mode", ")", ",", "0", ")", ".", "require", "(", ")", ";", "return", "mode", ";", "}", "else", "{", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "BITS_PER_WORD", ")", "return", "mode_for_size", "(", "BITS_PER_WORD", ",", "GET_MODE_CLASS", "(", "mode", ")", ",", "0", ")", ".", "require", "(", ")", ";", "return", "mode", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_SECONDARY_MEMORY_NEEDED_MODE", ".", "get_secondary_mem", "widens", "its", "argument", "to", "BITS_PER_WORD", "which", "loses", "on", "v9", "because", "the", "movsi", "and", "movsf", "patterns", "do", "n't", "handle", "r/f", "moves", ".", "For", "v8", "we", "copy", "the", "default", "definition", "." ]

[ "sparc", "32", "32", "0", "0" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "new", "CoalesceFeaturesAndStripAtomics", "(", "&", "getWebAssemblyTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyAddMissingPrototypes", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerGlobalDtors", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "checkSanityForEHAndSjLj", "(", "TM", ")", ";", "if", "(", "!", "WasmEnableEmEH", "&&", "!", "WasmEnableEH", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "WasmEnableEmEH", "||", "WasmEnableEmSjLj", "||", "WasmEnableSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", ")", ")", ";", "addPass", "(", "createIndirectBrExpandPass", "(", ")", ")", ";", "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>", "static", "void", "nios2_init_libfuncs", "(", "void", ")", "{", "if", "(", "TARGET_LINUX_ABI", ")", "init_sync_libfuncs", "(", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_INIT_LIBFUNCS", "." ]

[ "nios2" ]

[]

[ "<s>", "bool", "mips_expand_block_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "length", ")", "{", "if", "(", "!", "ISA_HAS_LWL_LWR", "&&", "(", "MEM_ALIGN", "(", "src", ")", "<", "MIPS_MIN_MOVE_MEM_ALIGN", "||", "MEM_ALIGN", "(", "dest", ")", "<", "MIPS_MIN_MOVE_MEM_ALIGN", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "length", ")", ")", "{", "if", "(", "INTVAL", "(", "length", ")", "<=", "MIPS_MAX_MOVE_BYTES_STRAIGHT", ")", "{", "mips_block_move_straight", "(", "dest", ",", "src", ",", "INTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "optimize", ")", "{", "mips_block_move_loop", "(", "dest", ",", "src", ",", "INTVAL", "(", "length", ")", ",", "MIPS_MAX_MOVE_BYTES_PER_LOOP_ITER", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "movmemsi", "instruction", ",", "which", "copies", "LENGTH", "bytes", "from", "memory", "reference", "SRC", "to", "memory", "reference", "DEST", "." ]

[ "mips" ]

[]

[ "<s>", "void", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "loadRegFromStack", "(", "MBB", ",", "MBBI", ",", "DestReg", ",", "FrameIndex", ",", "RC", ",", "TRI", ",", "0", ")", ";", "}", "</s>" ]

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

[ "Mips", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"GBZ80 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "GBZ80", "\"GBZ80 Assembly Printer\"" ]

[]

[ "<s>", "bool", "prepare_move_operands", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "if", "(", "1", ")", "{", "if", "(", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "0", "]", ",", "Pmode", ")", ")", "operands", "[", "0", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "0", "]", ")", ";", "else", "if", "(", "mode", "==", "SImode", "&&", "flag_pic", "&&", "SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "{", "emit_pic_move", "(", "operands", ",", "SImode", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "!=", "MEM", "&&", "!", "TARGET_NO_SDATA_SET", "&&", "small_data_pattern", "(", "operands", "[", "1", "]", ",", "Pmode", ")", ")", "{", "operands", "[", "1", "]", "=", "arc_rewrite_small_data", "(", "operands", "[", "1", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ";", "return", "true", ";", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", "&&", "!", "(", "reload_in_progress", "||", "reload_completed", ")", ")", "{", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "if", "(", "!", "move_dest_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "{", "rtx", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ")", ";", "rtx", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "addr", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "if", "(", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "0", "]", ")", ";", "operands", "[", "0", "]", "=", "pat", ";", "}", "}", "}", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", "&&", "!", "cse_not_expected", ")", "{", "rtx", "pat", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "pat", "=", "arc_legitimize_address_0", "(", "pat", ",", "pat", ",", "mode", ")", ";", "if", "(", "pat", ")", "{", "pat", "=", "change_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "pat", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "pat", ",", "operands", "[", "1", "]", ")", ";", "operands", "[", "1", "]", "=", "pat", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Prepare", "operands", "for", "a", "move", "define_expand", "in", "MODE", "." ]

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

[]

[ "<s>", "static", "rtx", "pdp11_function_arg", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_FUNCTION_ARG", ".", "Determine", "where", "to", "put", "an", "argument", "to", "a", "function", ".", "Value", "is", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", "(", "as", "a", "tree", ")", ".", "This", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "is", "a", "variable", "of", "type", "CUMULATIVE_ARGS", "which", "gives", "info", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "pdp11" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "SITargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "const", "unsigned", "BitWidth", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "case", "'s'", ":", "case", "'r'", ":", "switch", "(", "BitWidth", ")", "{", "case", "16", ":", "RC", "=", "&", "AMDGPU", "::", "SReg_32RegClass", ";", "break", ";", "case", "64", ":", "RC", "=", "&", "AMDGPU", "::", "SGPR_64RegClass", ";", "break", ";", "default", ":", "RC", "=", "SIRegisterInfo", "::", "getSGPRClassForBitWidth", "(", "BitWidth", ")", ";", "if", "(", "!", "RC", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "break", ";", "}", "break", ";", "case", "'v'", ":", "switch", "(", "BitWidth", ")", "{", "case", "16", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "default", ":", "RC", "=", "SIRegisterInfo", "::", "getVGPRClassForBitWidth", "(", "BitWidth", ")", ";", "if", "(", "!", "RC", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "break", ";", "}", "break", ";", "case", "'a'", ":", "if", "(", "!", "Subtarget", "->", "hasMAIInsts", "(", ")", ")", "break", ";", "switch", "(", "BitWidth", ")", "{", "case", "16", ":", "RC", "=", "&", "AMDGPU", "::", "AGPR_32RegClass", ";", "break", ";", "default", ":", "RC", "=", "SIRegisterInfo", "::", "getAGPRClassForBitWidth", "(", "BitWidth", ")", ";", "if", "(", "!", "RC", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "nullptr", ")", ";", "break", ";", "}", "break", ";", "}", "if", "(", "RC", "&&", "(", "isTypeLegal", "(", "VT", ")", "||", "VT", ".", "SimpleTy", "==", "MVT", "::", "i128", "||", "VT", ".", "SimpleTy", "==", "MVT", "::", "i16", "||", "VT", ".", "SimpleTy", "==", "MVT", "::", "f16", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "RC", ")", ";", "}", "if", "(", "Constraint", ".", "size", "(", ")", ">", "1", ")", "{", "if", "(", "Constraint", "[", "1", "]", "==", "'v'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'s'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "}", "else", "if", "(", "Constraint", "[", "1", "]", "==", "'a'", ")", "{", "RC", "=", "&", "AMDGPU", "::", "AGPR_32RegClass", ";", "}", "if", "(", "RC", ")", "{", "uint32_t", "Idx", ";", "bool", "Failed", "=", "Constraint", ".", "substr", "(", "2", ")", ".", "getAsInteger", "(", "10", ",", "Idx", ")", ";", "if", "(", "!", "Failed", "&&", "Idx", "<", "RC", "->", "getNumRegs", "(", ")", ")", "return", "std", "::", "make_pair", "(", "RC", "->", "getRegister", "(", "Idx", ")", ",", "RC", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "1", "0", "16", "AMDGPU::SReg_32RegClass", "64", "AMDGPU::SGPR_64RegClass", "SI", "0U", "16", "AMDGPU::VGPR_32RegClass", "SI", "0U", "16", "AMDGPU::AGPR_32RegClass", "SI", "0U", "MVT::i128", "MVT::i16", "MVT::f16", "0U", "1", "1", "AMDGPU::VGPR_32RegClass", "1", "AMDGPU::SGPR_32RegClass", "1", "AMDGPU::AGPR_32RegClass", "2", "10" ]

[]

[ "<s>", "void", "RISCVInstrInfo", "::", "buildOutlinedFrame", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "OutlinedFunction", "&", "OF", ")", "const", "{", "bool", "Changed", "=", "true", ";", "while", "(", "Changed", ")", "{", "Changed", "=", "false", ";", "auto", "I", "=", "MBB", ".", "begin", "(", ")", ";", "auto", "E", "=", "MBB", ".", "end", "(", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCFIInstruction", "(", ")", ")", "{", "I", "->", "removeFromParent", "(", ")", ";", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "MBB", ".", "addLiveIn", "(", "RISCV", "::", "X5", ")", ";", "MBB", ".", "insert", "(", "MBB", ".", "end", "(", ")", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "RISCV", "::", "JALR", ")", ")", ".", "addReg", "(", "RISCV", "::", "X0", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "RISCV", "::", "X5", ")", ".", "addImm", "(", "0", ")", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::X5", "RISCV::JALR", "RISCV::X0", "RISCV::X5", "0" ]

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", "<<", "\"(\"", "<<", "AArch64_AM", "::", "getFPImmFloat", "(", "getFPImm", "(", ")", ")", "<<", "\") >\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "StringRef", "Name", "=", "getBarrierName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "k_ShiftedImm", ":", "{", "unsigned", "Shift", "=", "getShiftedImmShift", "(", ")", ";", "OS", "<<", "\"<shiftedimm \"", ";", "OS", "<<", "*", "getShiftedImmVal", "(", ")", ";", "OS", "<<", "\", lsl #\"", "<<", "AArch64_AM", "::", "getShiftValue", "(", "Shift", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_CondCode", ":", "OS", "<<", "\"<condcode \"", "<<", "getCondCode", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "StringRef", "Name", "=", "getPrefetchName", "(", ")", ";", "if", "(", "!", "Name", ".", "empty", "(", ")", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_PSBHint", ":", "OS", "<<", "getPSBHintName", "(", ")", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "if", "(", "!", "getShiftExtendAmount", "(", ")", "&&", "!", "hasShiftExtendAmount", "(", ")", ")", "break", ";", "LLVM_FALLTHROUGH", ";", "case", "k_ShiftExtend", ":", "OS", "<<", "\"<\"", "<<", "AArch64_AM", "::", "getShiftExtendName", "(", "getShiftExtendType", "(", ")", ")", "<<", "\" #\"", "<<", "getShiftExtendAmount", "(", ")", ";", "if", "(", "!", "hasShiftExtendAmount", "(", ")", ")", "OS", "<<", "\"<imp>\"", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"<fpimm \"", "\"(\"", "AArch64_AM::getFPImmFloat", "\") >\"", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<shiftedimm \"", "\", lsl #\"", "AArch64_AM::getShiftValue", "\">\"", "\"<condcode \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<register \"", "\">\"", "\"<\"", "AArch64_AM::getShiftExtendName", "\" #\"", "\"<imp>\"" ]

[]

[ "<s>", "bool", "X86ExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "STI", "=", "&", "static_cast", "<", "const", "X86Subtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "X86FL", "=", "STI", "->", "getFrameLowering", "(", ")", ";", "bool", "Modified", "=", "ExpandPseudosWhichAffectControlFlow", "(", "MF", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Modified", "|=", "ExpandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldScheduleLoadsNear", "(", "SDNode", "*", "Load0", ",", "SDNode", "*", "Load1", ",", "int64_t", "Offset0", ",", "int64_t", "Offset1", ",", "unsigned", "NumLoads", ")", "const", "{", "assert", "(", "Offset1", ">", "Offset0", "&&", "\"Second offset should be larger than first offset!\"", ")", ";", "return", "(", "NumLoads", "<=", "16", "&&", "(", "Offset1", "-", "Offset0", ")", "<", "64", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"Second offset should be larger than first offset!\"", "16", "64" ]

[]

[ "<s>", "void", "PPCLinuxAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "!", "Subtarget", "->", "isPPC64", "(", ")", "&&", "(", "!", "isPositionIndependent", "(", ")", "||", "MF", "->", "getFunction", "(", ")", ".", "getParent", "(", ")", "->", "getPICLevel", "(", ")", "==", "PICLevel", "::", "SmallPIC", ")", ")", "return", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "isPPC64", "(", ")", ")", "{", "const", "PPCFunctionInfo", "*", "PPCFI", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "if", "(", "PPCFI", "->", "usesPICBase", "(", ")", "&&", "!", "Subtarget", "->", "isSecurePlt", "(", ")", ")", "{", "MCSymbol", "*", "RelocSymbol", "=", "PPCFI", "->", "getPICOffsetSymbol", "(", ")", ";", "MCSymbol", "*", "PICBase", "=", "MF", "->", "getPICBaseSymbol", "(", ")", ";", "OutStreamer", "->", "emitLabel", "(", "RelocSymbol", ")", ";", "const", "MCExpr", "*", "OffsExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "\".LTOC\"", ")", ")", ",", "OutContext", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "PICBase", ",", "OutContext", ")", ",", "OutContext", ")", ";", "OutStreamer", "->", "emitValue", "(", "OffsExpr", ",", "4", ")", ";", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "return", ";", "}", "else", "return", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "if", "(", "Subtarget", "->", "isELFv2ABI", "(", ")", ")", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "!", "MF", "->", "getRegInfo", "(", ")", ".", "use_empty", "(", "PPC", "::", "X2", ")", ")", "{", "const", "PPCFunctionInfo", "*", "PPCFI", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "MCSymbol", "*", "TOCSymbol", "=", "OutContext", ".", "getOrCreateSymbol", "(", "StringRef", "(", "\".TOC.\"", ")", ")", ";", "MCSymbol", "*", "GlobalEPSymbol", "=", "PPCFI", "->", "getGlobalEPSymbol", "(", ")", ";", "const", "MCExpr", "*", "TOCDeltaExpr", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "TOCSymbol", ",", "OutContext", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "GlobalEPSymbol", ",", "OutContext", ")", ",", "OutContext", ")", ";", "OutStreamer", "->", "emitLabel", "(", "PPCFI", "->", "getTOCOffsetSymbol", "(", ")", ")", ";", "OutStreamer", "->", "emitValue", "(", "TOCDeltaExpr", ",", "8", ")", ";", "}", "return", "AsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", ";", "}", "MCSectionSubPair", "Current", "=", "OutStreamer", "->", "getCurrentSection", "(", ")", ";", "MCSectionELF", "*", "Section", "=", "OutStreamer", "->", "getContext", "(", ")", ".", "getELFSection", "(", "\".opd\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Section", ")", ";", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "emitValueToAlignment", "(", "8", ")", ";", "MCSymbol", "*", "Symbol1", "=", "CurrentFnSymForSize", ";", "OutStreamer", "->", "emitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "Symbol1", ",", "OutContext", ")", ",", "8", ")", ";", "MCSymbol", "*", "Symbol2", "=", "OutContext", ".", "getOrCreateSymbol", "(", "StringRef", "(", "\".TOC.\"", ")", ")", ";", "OutStreamer", "->", "emitValue", "(", "MCSymbolRefExpr", "::", "create", "(", "Symbol2", ",", "MCSymbolRefExpr", "::", "VK_PPC_TOCBASE", ",", "OutContext", ")", ",", "8", ")", ";", "OutStreamer", "->", "emitIntValue", "(", "0", ",", "8", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Current", ".", "first", ",", "Current", ".", "second", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "\".LTOC\"", "4", "PPC::X2", "PPC", "PPC", "PPC", "\".TOC.\"", "PPC", "PPC", "8", "\".opd\"", "8", "8", "\".TOC.\"", "PPC", "8", "0", "8" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_nregs_internal", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "reg_size", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", "?", "UNITS_PER_VSX_WORD", ":", "UNITS_PER_FP_WORD", ")", ";", "else", "if", "(", "SPE_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "reg_size", "=", "UNITS_PER_SPE_WORD", ";", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_ALTIVEC_WORD", ";", "else", "if", "(", "TARGET_E500_DOUBLE", "&&", "FLOAT_MODE_P", "(", "mode", ")", "&&", "mode", "!=", "SCmode", "&&", "!", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", "&&", "SPE_SIMD_REGNO_P", "(", "regno", ")", ")", "reg_size", "=", "UNITS_PER_FP_WORD", ";", "else", "reg_size", "=", "UNITS_PER_WORD", ";", "return", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "reg_size", "-", "1", ")", "/", "reg_size", ";", "}", "</s>" ]

[ "Return", "number", "of", "consecutive", "hard", "regs", "needed", "starting", "at", "reg", "REGNO", "to", "hold", "something", "of", "mode", "MODE", ".", "This", "is", "ordinarily", "the", "length", "in", "words", "of", "a", "value", "of", "mode", "MODE", "but", "can", "be", "less", "for", "certain", "modes", "in", "special", "long", "registers", ".", "POWER", "and", "PowerPC", "GPRs", "hold", "32", "bits", "worth", ";", "PowerPC64", "GPRs", "and", "FPRs", "point", "register", "holds", "64", "bits", "worth", "." ]

[ "powerpcspe", "1" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_reencode", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "expand_vec_perm_d", "newd", ";", "unsigned", "HOST_WIDE_INT", "nelt", ";", "if", "(", "d", "->", "vec_flags", "!=", "VEC_ADVSIMD", ")", "return", "false", ";", "poly_uint64", "vec_bits", "=", "GET_MODE_BITSIZE", "(", "d", "->", "vmode", ")", ";", "unsigned", "int", "new_elt_bits", "=", "GET_MODE_UNIT_BITSIZE", "(", "d", "->", "vmode", ")", "*", "2", ";", "auto", "new_elt_mode", "=", "int_mode_for_size", "(", "new_elt_bits", ",", "false", ")", ".", "require", "(", ")", ";", "machine_mode", "new_mode", "=", "aarch64_simd_container_mode", "(", "new_elt_mode", ",", "vec_bits", ")", ";", "if", "(", "new_mode", "==", "word_mode", ")", "return", "false", ";", "nelt", "=", "d", "->", "perm", ".", "length", "(", ")", ".", "to_constant", "(", ")", ";", "vec_perm_builder", "newpermconst", ";", "newpermconst", ".", "new_vector", "(", "nelt", "/", "2", ",", "nelt", "/", "2", ",", "1", ")", ";", "for", "(", "unsigned", "int", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "2", ")", "{", "poly_int64", "elt0", "=", "d", "->", "perm", "[", "i", "]", ";", "poly_int64", "elt1", "=", "d", "->", "perm", "[", "i", "+", "1", "]", ";", "poly_int64", "newelt", ";", "if", "(", "!", "multiple_p", "(", "elt0", ",", "2", ",", "&", "newelt", ")", "||", "maybe_ne", "(", "elt0", "+", "1", ",", "elt1", ")", ")", "return", "false", ";", "newpermconst", ".", "quick_push", "(", "newelt", ".", "to_constant", "(", ")", ")", ";", "}", "newpermconst", ".", "finalize", "(", ")", ";", "newd", ".", "vmode", "=", "new_mode", ";", "newd", ".", "vec_flags", "=", "VEC_ADVSIMD", ";", "newd", ".", "target", "=", "d", "->", "target", "?", "gen_lowpart", "(", "new_mode", ",", "d", "->", "target", ")", ":", "NULL", ";", "newd", ".", "op0", "=", "d", "->", "op0", "?", "gen_lowpart", "(", "new_mode", ",", "d", "->", "op0", ")", ":", "NULL", ";", "newd", ".", "op1", "=", "d", "->", "op1", "?", "gen_lowpart", "(", "new_mode", ",", "d", "->", "op1", ")", ":", "NULL", ";", "newd", ".", "testing_p", "=", "d", "->", "testing_p", ";", "newd", ".", "one_vector_p", "=", "d", "->", "one_vector_p", ";", "newd", ".", "perm", ".", "new_vector", "(", "newpermconst", ",", "newd", ".", "one_vector_p", "?", "1", ":", "2", ",", "nelt", "/", "2", ")", ";", "return", "aarch64_expand_vec_perm_const_1", "(", "&", "newd", ")", ";", "}", "</s>" ]

[ "Try", "to", "re-encode", "the", "PERM", "constant", "so", "it", "combines", "odd", "and", "even", "elements", ".", "This", "rewrites", "constants", "such", "as", "{", "0", ",", "1", ",", "4", ",", "5", "}", "/V4SF", "to", "{", "0", ",", "2", "}", "/V2DI", ".", "We", "retry", "with", "this", "new", "constant", "with", "the", "full", "suite", "of", "patterns", "." ]

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

[]

[ "<s>", "static", "int", "riscv_address_cost", "(", "rtx", "addr", ",", "enum", "machine_mode", "mode", ",", "addr_space_t", "as", "ATTRIBUTE_UNUSED", ",", "bool", "speed", "ATTRIBUTE_UNUSED", ")", "{", "return", "riscv_address_insns", "(", "addr", ",", "mode", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ADDRESS_COST", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "FixupBWInstPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "FixupBWInsts", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "this", "->", "MF", "=", "&", "MF", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "PSI", "=", "&", "getAnalysis", "<", "ProfileSummaryInfoWrapperPass", ">", "(", ")", ".", "getPSI", "(", ")", ";", "MBFI", "=", "(", "PSI", "&&", "PSI", "->", "hasProfileSummary", "(", ")", ")", "?", "&", "getAnalysis", "<", "LazyMachineBlockFrequencyInfoPass", ">", "(", ")", ".", "getBFI", "(", ")", ":", "nullptr", ";", "LiveRegs", ".", "init", "(", "TII", "->", "getRegisterInfo", "(", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupBWInsts\\n\"", ";", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "processBasicBlock", "(", "MF", ",", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupBWInsts\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Start X86FixupBWInsts\\n\"", "\"End X86FixupBWInsts\\n\"" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "MipsRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "case", "G_GEP", ":", "case", "G_AND", ":", "case", "G_OR", ":", "case", "G_XOR", ":", "case", "G_SHL", ":", "case", "G_ASHR", ":", "case", "G_LSHR", ":", "case", "G_SDIV", ":", "case", "G_UDIV", ":", "case", "G_SREM", ":", "case", "G_UREM", ":", "OperandsMapping", "=", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ";", "break", ";", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "case", "G_GLOBAL_VALUE", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "case", "G_ICMP", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "nullptr", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", "}", ")", ";", "break", ";", "case", "G_SELECT", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", ",", "&", "Mips", "::", "ValueMappings", "[", "Mips", "::", "GPRIdx", "]", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "Mips", "Mips", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "Mips::ValueMappings", "Mips::GPRIdx", "1" ]

[]

[ "<s>", "bool", "X86AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "static", "const", "uint8_t", "Nops", "[", "10", "]", "[", "10", "]", "=", "{", "{", "0x90", "}", ",", "{", "0x66", ",", "0x90", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x40", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x44", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x80", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "{", "0x66", ",", "0x2e", ",", "0x0f", ",", "0x1f", ",", "0x84", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", ",", "0x00", "}", ",", "}", ";", "const", "uint64_t", "OptimalCount", "=", "(", "Count", "<", "16", ")", "?", "Count", ":", "15", ";", "const", "uint64_t", "Prefixes", "=", "OptimalCount", "<=", "10", "?", "0", ":", "OptimalCount", "-", "10", ";", "for", "(", "uint64_t", "i", "=", "0", ",", "e", "=", "Prefixes", ";", "i", "!=", "e", ";", "i", "++", ")", "OW", "->", "Write8", "(", "0x66", ")", ";", "const", "uint64_t", "Rest", "=", "OptimalCount", "-", "Prefixes", ";", "for", "(", "uint64_t", "i", "=", "0", ",", "e", "=", "Rest", ";", "i", "!=", "e", ";", "i", "++", ")", "OW", "->", "Write8", "(", "Nops", "[", "Rest", "-", "1", "]", "[", "i", "]", ")", ";", "for", "(", "uint64_t", "i", "=", "OptimalCount", ",", "e", "=", "Count", ";", "i", "!=", "e", ";", "++", "i", ")", "OW", "->", "Write8", "(", "0x90", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "X86", "X86", "10", "10", "0x90", "0x66", "0x90", "0x0f", "0x1f", "0x00", "0x0f", "0x1f", "0x40", "0x00", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x44", "0x00", "0x00", "0x0f", "0x1f", "0x80", "0x00", "0x00", "0x00", "0x00", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "0x66", "0x2e", "0x0f", "0x1f", "0x84", "0x00", "0x00", "0x00", "0x00", "0x00", "16", "15", "10", "0", "10", "0", "0x66", "0", "1", "0x90" ]

[]

[ "<s>", "rtx", "spu_float_const", "(", "const", "char", "*", "string", ",", "machine_mode", "mode", ")", "{", "REAL_VALUE_TYPE", "value", ";", "value", "=", "REAL_VALUE_ATOF", "(", "string", ",", "mode", ")", ";", "return", "const_double_from_real_value", "(", "value", ",", "mode", ")", ";", "}", "</s>" ]

[ "Create", "a", "CONST_DOUBLE", "from", "a", "string", "." ]

[ "spu" ]

[]

[ "<s>", "static", "int", "arm_compute_static_chain_stack_bytes", "(", "void", ")", "{", "if", "(", "IS_NESTED", "(", "arm_current_func_type", "(", ")", ")", "&&", "(", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "TARGET_ARM", ")", "||", "(", "flag_stack_check", "==", "STATIC_BUILTIN_STACK_CHECK", "&&", "!", "df_regs_ever_live_p", "(", "LR_REGNUM", ")", ")", ")", "&&", "arm_r3_live_at_start_p", "(", ")", "&&", "crtl", "->", "args", ".", "pretend_args_size", "==", "0", ")", "return", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "bytes", "used", "to", "store", "the", "static", "chain", "register", "on", "the", "stack", ",", "above", "the", "stack", "frame", ".", "We", "need", "to", "know", "this", "accurately", "to", "get", "the", "alignment", "of", "the", "rest", "of", "the", "stack", "frame", "correct", "." ]

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

[]

[ "<s>", "int", "direct_return", "(", "void", ")", "{", "return", "(", "reload_completed", "&&", "xstormy16_compute_stack_layout", "(", ")", ".", "frame_size", "==", "0", "&&", "!", "xstormy16_interrupt_function_p", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "this", "function", "is", "known", "to", "have", "a", "null", "epilogue", "." ]

[ "stormy16", "0" ]

[]

[ "<s>", "bool", "SNITCHFrepLoops", "::", "isDead", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DeadPhis", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MRI", "->", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "using", "use_nodbg_iterator", "=", "MachineRegisterInfo", "::", "use_nodbg_iterator", ";", "use_nodbg_iterator", "I", "=", "MRI", "->", "use_nodbg_begin", "(", "Reg", ")", ";", "use_nodbg_iterator", "End", "=", "MRI", "->", "use_nodbg_end", "(", ")", ";", "if", "(", "std", "::", "next", "(", "I", ")", "!=", "End", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" not dead because >2 uses\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "I", "->", "getParent", "(", ")", "->", "isPHI", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" not dead because use is not PHI\\n\"", ")", ";", "return", "false", ";", "}", "MachineInstr", "*", "UsePhi", "=", "I", "->", "getParent", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "f", "=", "UsePhi", "->", "getNumOperands", "(", ")", ";", "j", "!=", "f", ";", "++", "j", ")", "{", "const", "MachineOperand", "&", "OPO", "=", "UsePhi", "->", "getOperand", "(", "j", ")", ";", "if", "(", "!", "OPO", ".", "isReg", "(", ")", "||", "!", "OPO", ".", "isDef", "(", ")", ")", "continue", ";", "unsigned", "OPReg", "=", "OPO", ".", "getReg", "(", ")", ";", "use_nodbg_iterator", "nextJ", ";", "for", "(", "use_nodbg_iterator", "J", "=", "MRI", "->", "use_nodbg_begin", "(", "OPReg", ")", ";", "J", "!=", "End", ";", "J", "=", "nextJ", ")", "{", "nextJ", "=", "std", "::", "next", "(", "J", ")", ";", "MachineOperand", "&", "Use", "=", "*", "J", ";", "MachineInstr", "*", "UseMI", "=", "Use", ".", "getParent", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" checking use:\\n\"", ";", "UseMI", "->", "dump", "(", ")", ")", ";", "if", "(", "MI", "!=", "UseMI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" not dead because the phi node has a user that is not MI\\n\"", ")", ";", "return", "false", ";", "}", "}", "}", "DeadPhis", ".", "push_back", "(", "UsePhi", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

[ "RI5CY", "0", "\" not dead because >2 uses\\n\"", "\" not dead because use is not PHI\\n\"", "0", "\" checking use:\\n\"", "\" not dead because the phi node has a user that is not MI\\n\"" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "post", "PEI", "scavenging", "of", "registers", "for", "materializing", "frame", "index", "constants", "." ]

[ "Teak", "Teak" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createThumb2SizeReductionPass", "(", ")", ")", ";", "if", "(", "getARMSubtarget", "(", ")", ".", "isThumb2", "(", ")", ")", "addPass", "(", "&", "UnpackMachineBundlesID", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createARMOptimizeBarriersPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

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

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

[ "ARM" ]

[]

[ "<s>", "void", "RISCVPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "TargetFrameLowering", "&", "TFI", "=", "*", "Subtarget", "->", "getFrameLowering", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"esp\"", ",", "X86", "::", "ESP", ")", ".", "Case", "(", "\"rsp\"", ",", "X86", "::", "RSP", ")", ".", "Case", "(", "\"ebp\"", ",", "X86", "::", "EBP", ")", ".", "Case", "(", "\"rbp\"", ",", "X86", "::", "RBP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", "==", "X86", "::", "EBP", "||", "Reg", "==", "X86", "::", "RBP", ")", "{", "if", "(", "!", "TFI", ".", "hasFP", "(", "MF", ")", ")", "report_fatal_error", "(", "\"register \"", "+", "StringRef", "(", "RegName", ")", "+", "\" is allocatable: function has no frame pointer\"", ")", ";", "else", "{", "const", "X86RegisterInfo", "*", "RegInfo", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "unsigned", "FrameReg", "=", "RegInfo", "->", "getPtrSizedFrameRegister", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "assert", "(", "(", "FrameReg", "==", "X86", "::", "EBP", "||", "FrameReg", "==", "X86", "::", "RBP", ")", "&&", "\"Invalid Frame Register!\"", ")", ";", "}", "}", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "X86", "X86", "\"esp\"", "X86::ESP", "\"rsp\"", "X86::RSP", "\"ebp\"", "X86::EBP", "\"rbp\"", "X86::RBP", "0", "X86::EBP", "X86::RBP", "\"register \"", "\" is allocatable: function has no frame pointer\"", "X86", "X86::EBP", "X86::RBP", "\"Invalid Frame Register!\"", "\"Invalid register name global variable\"" ]

[]

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

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

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

[]

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

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

[ "Cpu0" ]

[]

[ "<s>", "bool", "CopyPropagation", "::", "processBlock", "(", "MachineBasicBlock", "&", "B", ",", "const", "RegisterSet", "&", ")", "{", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "reverse", "(", "B", ")", ")", "Instrs", ".", "push_back", "(", "&", "MI", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "I", ":", "Instrs", ")", "{", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "!", "CopyPropagation", "::", "isCopyReg", "(", "Opc", ",", "true", ")", ")", "continue", ";", "Changed", "|=", "propagateRegCopy", "(", "*", "I", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", ">=", "MCID", ".", "getNumOperands", "(", ")", ")", "break", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "const", "MCOperandInfo", "&", "MCOI", "=", "MCID", ".", "OpInfo", "[", "I", "]", ";", "if", "(", "MCOI", ".", "OperandType", "==", "MCOI", "::", "OPERAND_MEMORY", "&&", "(", "(", "MCOI", ".", "RegClass", "!=", "-", "1", "&&", "!", "Op", ".", "isReg", "(", ")", "&&", "!", "Op", ".", "isFI", "(", ")", ")", "||", "(", "MCOI", ".", "RegClass", "==", "-", "1", "&&", "!", "Op", ".", "isImm", "(", ")", ")", ")", ")", "{", "ErrInfo", "=", "\"Addressing mode operands corrupt!\"", ";", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "0", "1", "1", "\"Addressing mode operands corrupt!\"" ]

[]

[ "<s>", "bool", "Z80AsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "OutStreamer", ".", "setAutoInitSections", "(", "false", ")", ";", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "MMI", "->", "AnalyzeModule", "(", "M", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", "&", "TM", ")", ";", "emitHeader", "(", "M", ",", "OS1", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "!", "M", ".", "getModuleInlineAsm", "(", ")", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "AddComment", "(", "\"Start of file scope inline assembly\"", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "StringRef", "(", "M", ".", "getModuleInlineAsm", "(", ")", ")", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "OutStreamer", ".", "AddComment", "(", "\"End of file scope inline assembly\"", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"" ]

[]

[ "<s>", "auto", "HexagonVectorCombine", "::", "getNullValue", "(", "Type", "*", "Ty", ")", "const", "->", "Constant", "*", "{", "assert", "(", "Ty", "->", "isIntOrIntVectorTy", "(", ")", ")", ";", "auto", "Zero", "=", "ConstantInt", "::", "get", "(", "Ty", "->", "getScalarType", "(", ")", ",", "0", ")", ";", "if", "(", "auto", "*", "VecTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "Ty", ")", ")", "return", "ConstantVector", "::", "getSplat", "(", "VecTy", "->", "getElementCount", "(", ")", ",", "Zero", ")", ";", "return", "Zero", ";", "}", "</s>" ]

[ "Constructor", "to", "create", "a", "'", "0", "'", "constant", "of", "arbitrary", "type", "." ]

[ "Hexagon", "HexagonVectorCombine::getNullValue", "0" ]

[]

[ "<s>", "rtx", "mn10300_legitimize_pic_address", "(", "rtx", "orig", ",", "rtx", "reg", ")", "{", "rtx", "x", ";", "rtx_insn", "*", "insn", ";", "if", "(", "GET_CODE", "(", "orig", ")", "==", "LABEL_REF", "||", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", "&&", "(", "CONSTANT_POOL_ADDRESS_P", "(", "orig", ")", "||", "!", "MN10300_GLOBAL_P", "(", "orig", ")", ")", ")", ")", "{", "if", "(", "reg", "==", "NULL", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "orig", ")", ",", "UNSPEC_GOTOFF", ")", ";", "x", "=", "gen_rtx_CONST", "(", "SImode", ",", "x", ")", ";", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "reg", ",", "reg", ",", "pic_offset_table_rtx", ")", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "orig", ")", "==", "SYMBOL_REF", ")", "{", "if", "(", "reg", "==", "NULL", ")", "reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "SImode", ",", "gen_rtvec", "(", "1", ",", "orig", ")", ",", "UNSPEC_GOT", ")", ";", "x", "=", "gen_rtx_CONST", "(", "SImode", ",", "x", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "SImode", ",", "pic_offset_table_rtx", ",", "x", ")", ";", "x", "=", "gen_const_mem", "(", "SImode", ",", "x", ")", ";", "insn", "=", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "}", "else", "return", "orig", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "orig", ")", ";", "return", "reg", ";", "}", "</s>" ]

[ "Convert", "a", "non-PIC", "address", "in", "`", "orig", "'", "to", "a", "PIC", "address", "using", "@", "GOT", "or", "@", "GOTOFF", "in", "`", "reg", "'", "." ]

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

[]

[ "<s>", "void", "mips_emit_save_slot_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "temp", ")", "{", "unsigned", "int", "regno", ";", "rtx", "mem", ";", "if", "(", "REG_P", "(", "src", ")", ")", "{", "regno", "=", "REGNO", "(", "src", ")", ";", "mem", "=", "dest", ";", "}", "else", "{", "regno", "=", "REGNO", "(", "dest", ")", ";", "mem", "=", "src", ";", "}", "if", "(", "regno", "==", "cfun", "->", "machine", "->", "global_pointer", "&&", "!", "mips_must_initialize_gp_p", "(", ")", ")", "{", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_move_gpdi", "(", "dest", ",", "src", ")", ")", ";", "else", "emit_insn", "(", "gen_move_gpsi", "(", "dest", ",", "src", ")", ")", ";", "return", ";", "}", "if", "(", "regno", "==", "HI_REGNUM", ")", "{", "if", "(", "REG_P", "(", "dest", ")", ")", "{", "mips_emit_move", "(", "temp", ",", "src", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mthidi_ti", "(", "gen_rtx_REG", "(", "TImode", ",", "MD_REG_FIRST", ")", ",", "temp", ",", "gen_rtx_REG", "(", "DImode", ",", "LO_REGNUM", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_mthisi_di", "(", "gen_rtx_REG", "(", "DImode", ",", "MD_REG_FIRST", ")", ",", "temp", ",", "gen_rtx_REG", "(", "SImode", ",", "LO_REGNUM", ")", ")", ")", ";", "}", "else", "{", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mfhidi_ti", "(", "temp", ",", "gen_rtx_REG", "(", "TImode", ",", "MD_REG_FIRST", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_mfhisi_di", "(", "temp", ",", "gen_rtx_REG", "(", "DImode", ",", "MD_REG_FIRST", ")", ")", ")", ";", "mips_emit_move", "(", "dest", ",", "temp", ")", ";", "}", "}", "else", "if", "(", "mips_direct_save_slot_move_p", "(", "regno", ",", "mem", ",", "mem", "==", "src", ")", ")", "mips_emit_move", "(", "dest", ",", "src", ")", ";", "else", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "dest", ",", "temp", ")", ")", ";", "mips_emit_move", "(", "temp", ",", "src", ")", ";", "mips_emit_move", "(", "dest", ",", "temp", ")", ";", "}", "if", "(", "MEM_P", "(", "dest", ")", ")", "mips_set_frame_expr", "(", "mips_frame_set", "(", "dest", ",", "src", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "move", "from", "SRC", "to", "DEST", ",", "given", "that", "one", "of", "them", "is", "a", "register", "save", "slot", "and", "that", "the", "other", "is", "a", "register", ".", "TEMP", "is", "a", "temporary", "GPR", "of", "the", "same", "mode", "that", "is", "available", "if", "need", "be", "." ]

[ "mips" ]

[]

[ "<s>", "Printable", "print", "(", ")", "const", "{", "return", "Printable", "(", "[", "this", "]", "(", "raw_ostream", "&", "OS", ")", "{", "OS", "<<", "\"Value: \"", "<<", "*", "V", "<<", "'\\n'", "<<", "\"Base: \"", "<<", "*", "Base", "<<", "\" Offset: \"", "<<", "Offset", "<<", "'\\n'", ";", "}", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"Value: \"", "\"Base: \"", "\" Offset: \"" ]

[]

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

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

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

[]

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

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

[ "X86", "X86", "X86::VR128RegClass", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "void", "Z80oldAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "Z80oldMCInstLower", "MCInstLowering", "(", "*", "MF", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "Z80old", "Z80old", "Z80old" ]

[]

[ "<s>", "void", "scalar_chain", "::", "convert_reg", "(", "rtx_insn", "*", "insn", ",", "rtx", "dst", ",", "rtx", "src", ")", "{", "start_sequence", "(", ")", ";", "if", "(", "!", "TARGET_INTER_UNIT_MOVES_FROM_VEC", ")", "{", "rtx", "tmp", "=", "assign_386_stack_local", "(", "smode", ",", "SLOT_STV_TEMP", ")", ";", "emit_move_insn", "(", "tmp", ",", "src", ")", ";", "if", "(", "!", "TARGET_64BIT", "&&", "smode", "==", "DImode", ")", "{", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "0", ")", ",", "adjust_address", "(", "tmp", ",", "SImode", ",", "0", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "4", ")", ",", "adjust_address", "(", "tmp", ",", "SImode", ",", "4", ")", ")", ";", "}", "else", "emit_move_insn", "(", "dst", ",", "copy_rtx", "(", "tmp", ")", ")", ";", "}", "else", "if", "(", "!", "TARGET_64BIT", "&&", "smode", "==", "DImode", ")", "{", "if", "(", "TARGET_SSE4_1", ")", "{", "rtx", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "0", ")", ",", "gen_rtx_VEC_SELECT", "(", "SImode", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "src", ",", "0", ")", ",", "tmp", ")", ")", ")", ";", "tmp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "4", ")", ",", "gen_rtx_VEC_SELECT", "(", "SImode", ",", "gen_rtx_SUBREG", "(", "V4SImode", ",", "src", ",", "0", ")", ",", "tmp", ")", ")", ")", ";", "}", "else", "{", "rtx", "vcopy", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "emit_move_insn", "(", "vcopy", ",", "gen_rtx_SUBREG", "(", "V2DImode", ",", "src", ",", "0", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "vcopy", ",", "0", ")", ")", ";", "emit_move_insn", "(", "vcopy", ",", "gen_rtx_LSHIFTRT", "(", "V2DImode", ",", "vcopy", ",", "GEN_INT", "(", "32", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "dst", ",", "4", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "vcopy", ",", "0", ")", ")", ";", "}", "}", "else", "emit_move_insn", "(", "dst", ",", "src", ")", ";", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_conversion_insns", "(", "seq", ",", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Copied r%d to a scalar register r%d for insn %d\\n\"", ",", "REGNO", "(", "src", ")", ",", "REGNO", "(", "dst", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Convert", "all", "definitions", "of", "register", "REGNO", "and", "fix", "its", "uses", ".", "Scalar", "copies", "may", "be", "created", "in", "case", "register", "is", "used", "in", "not", "convertible", "insn", "." ]

[ "i386", "0", "0", "4", "4", "1", "0", "0", "1", "4", "0", "0", "0", "0", "32", "4", "0", "\" Copied r%d to a scalar register r%d for insn %d\\n\"" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "MMI", "->", "AnalyzeModule", "(", "M", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", "OutContext", ",", "*", "TM", ".", "getDataLayout", "(", ")", ")", ";", "emitHeader", "(", "M", ",", "OS1", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS1", ".", "str", "(", ")", ")", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "SmallString", "<", "128", ">", "Str2", ";", "raw_svector_ostream", "OS2", "(", "Str2", ")", ";", "emitDeclarations", "(", "M", ",", "OS2", ")", ";", "for", "(", "Module", "::", "global_iterator", "I", "=", "M", ".", "global_begin", "(", ")", ",", "E", "=", "M", ".", "global_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "printModuleLevelGV", "(", "I", ",", "OS2", ")", ";", "OS2", "<<", "'\\n'", ";", "OutStreamer", ".", "EmitRawText", "(", "OS2", ".", "str", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "128", "NVPTX::CUDA", "128" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "ARM64MCExpr", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "ARM64", "ARM64" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "\"Invalid opcode\"" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "if", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "{", "auto", "*", "Assembler", "=", "getTargetStreamer", "(", ")", ".", "getStreamer", "(", ")", ".", "getAssemblerPtr", "(", ")", ";", "if", "(", "Assembler", "!=", "nullptr", ")", "{", "RISCVAsmBackend", "&", "MAB", "=", "static_cast", "<", "RISCVAsmBackend", "&", ">", "(", "Assembler", "->", "getBackend", "(", ")", ")", ";", "MAB", ".", "setForceRelocs", "(", ")", ";", "}", "}", "Operands", ".", "push_back", "(", "RISCVOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ",", "isRV64", "(", ")", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "RISCV", "RISCV", "RISCV", "\"unexpected token\"" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isValidOffset", "(", "const", "int", "Opcode", ",", "const", "int", "Offset", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "Hexagon", "::", "LDriw", ":", "case", "Hexagon", "::", "LDriw_indexed", ":", "case", "Hexagon", "::", "LDriw_f", ":", "case", "Hexagon", "::", "STriw_indexed", ":", "case", "Hexagon", "::", "STriw", ":", "case", "Hexagon", "::", "STriw_f", ":", "return", "(", "Offset", ">=", "Hexagon_MEMW_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMW_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrid", ":", "case", "Hexagon", "::", "LDrid_indexed", ":", "case", "Hexagon", "::", "LDrid_f", ":", "case", "Hexagon", "::", "STrid", ":", "case", "Hexagon", "::", "STrid_indexed", ":", "case", "Hexagon", "::", "STrid_f", ":", "return", "(", "Offset", ">=", "Hexagon_MEMD_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMD_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrih", ":", "case", "Hexagon", "::", "LDriuh", ":", "case", "Hexagon", "::", "STrih", ":", "return", "(", "Offset", ">=", "Hexagon_MEMH_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMH_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "LDrib", ":", "case", "Hexagon", "::", "STrib", ":", "case", "Hexagon", "::", "LDriub", ":", "return", "(", "Offset", ">=", "Hexagon_MEMB_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_MEMB_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "ADD_ri", ":", "case", "Hexagon", "::", "TFR_FI", ":", "return", "(", "Offset", ">=", "Hexagon_ADDI_OFFSET_MIN", ")", "&&", "(", "Offset", "<=", "Hexagon_ADDI_OFFSET_MAX", ")", ";", "case", "Hexagon", "::", "MEMw_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMw_ORr_MEM_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "255", ")", ";", "case", "Hexagon", "::", "MEMh_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMh_ORr_MEM_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "127", ")", ";", "case", "Hexagon", "::", "MEMb_ADDi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBi_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ANDr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ORr_indexed_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDi_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBi_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ADDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_SUBr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ANDr_MEM_V4", ":", "case", "Hexagon", "::", "MEMb_ORr_MEM_V4", ":", "return", "(", "0", "<=", "Offset", "&&", "Offset", "<=", "63", ")", ";", "case", "Hexagon", "::", "STriw_pred", ":", "case", "Hexagon", "::", "LDriw_pred", ":", "return", "true", ";", "case", "Hexagon", "::", "LOOP0_i", ":", "return", "isUInt", "<", "10", ">", "(", "Offset", ")", ";", "case", "Hexagon", "::", "INLINEASM", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "Hexagon", "Hexagon", "Hexagon::LDriw", "Hexagon::LDriw_indexed", "Hexagon::LDriw_f", "Hexagon::STriw_indexed", "Hexagon::STriw", "Hexagon::STriw_f", "Hexagon", "Hexagon", "Hexagon::LDrid", "Hexagon::LDrid_indexed", "Hexagon::LDrid_f", "Hexagon::STrid", "Hexagon::STrid_indexed", "Hexagon::STrid_f", "Hexagon", "Hexagon", "Hexagon::LDrih", "Hexagon::LDriuh", "Hexagon::STrih", "Hexagon", "Hexagon", "Hexagon::LDrib", "Hexagon::STrib", "Hexagon::LDriub", "Hexagon", "Hexagon", "Hexagon::ADD_ri", "Hexagon::TFR_FI", "Hexagon", "Hexagon", "Hexagon::MEMw_ADDi_indexed_MEM_V4", "Hexagon::MEMw_SUBi_indexed_MEM_V4", "Hexagon::MEMw_ADDr_indexed_MEM_V4", "Hexagon::MEMw_SUBr_indexed_MEM_V4", "Hexagon::MEMw_ANDr_indexed_MEM_V4", "Hexagon::MEMw_ORr_indexed_MEM_V4", "Hexagon::MEMw_ADDi_MEM_V4", "Hexagon::MEMw_SUBi_MEM_V4", "Hexagon::MEMw_ADDr_MEM_V4", "Hexagon::MEMw_SUBr_MEM_V4", "Hexagon::MEMw_ANDr_MEM_V4", "Hexagon::MEMw_ORr_MEM_V4", "0", "255", "Hexagon::MEMh_ADDi_indexed_MEM_V4", "Hexagon::MEMh_SUBi_indexed_MEM_V4", "Hexagon::MEMh_ADDr_indexed_MEM_V4", "Hexagon::MEMh_SUBr_indexed_MEM_V4", "Hexagon::MEMh_ANDr_indexed_MEM_V4", "Hexagon::MEMh_ORr_indexed_MEM_V4", "Hexagon::MEMh_ADDi_MEM_V4", "Hexagon::MEMh_SUBi_MEM_V4", "Hexagon::MEMh_ADDr_MEM_V4", "Hexagon::MEMh_SUBr_MEM_V4", "Hexagon::MEMh_ANDr_MEM_V4", "Hexagon::MEMh_ORr_MEM_V4", "0", "127", "Hexagon::MEMb_ADDi_indexed_MEM_V4", "Hexagon::MEMb_SUBi_indexed_MEM_V4", "Hexagon::MEMb_ADDr_indexed_MEM_V4", "Hexagon::MEMb_SUBr_indexed_MEM_V4", "Hexagon::MEMb_ANDr_indexed_MEM_V4", "Hexagon::MEMb_ORr_indexed_MEM_V4", "Hexagon::MEMb_ADDi_MEM_V4", "Hexagon::MEMb_SUBi_MEM_V4", "Hexagon::MEMb_ADDr_MEM_V4", "Hexagon::MEMb_SUBr_MEM_V4", "Hexagon::MEMb_ANDr_MEM_V4", "Hexagon::MEMb_ORr_MEM_V4", "0", "63", "Hexagon::STriw_pred", "Hexagon::LDriw_pred", "Hexagon::LOOP0_i", "10", "Hexagon::INLINEASM", "\"No offset range is defined for this opcode. \"", "\"Please define it in the above switch statement!\"" ]

[]

[ "<s>", "bool", "MVEVPTOptimisations", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT Optimisations **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "{", "Modified", "|=", "ReplaceVCMPsByVPNOTs", "(", "MBB", ")", ";", "Modified", "|=", "ReduceOldVCCRValueUses", "(", "MBB", ")", ";", "Modified", "|=", "ConvertVPSEL", "(", "MBB", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT Optimisations **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "void", "MFMAIGroupLPDAGMutation", "::", "apply", "(", "ScheduleDAGInstrs", "*", "DAGInstrs", ")", "{", "const", "GCNSubtarget", "&", "ST", "=", "DAGInstrs", "->", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "ST", ".", "hasMAIInsts", "(", ")", ")", "return", ";", "DAG", "=", "static_cast", "<", "ScheduleDAGMI", "*", ">", "(", "DAGInstrs", ")", ";", "const", "TargetSchedModel", "*", "TSchedModel", "=", "DAGInstrs", "->", "getSchedModel", "(", ")", ";", "if", "(", "!", "TSchedModel", "||", "DAG", "->", "SUnits", ".", "empty", "(", ")", ")", "return", ";", "const", "IsInstructionType", "isMFMAFn", "=", "[", "this", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "TII", "->", "isMAI", "(", "MI", ")", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_WRITE_B32_e64", "&&", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "V_ACCVGPR_READ_B32_e64", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found MFMA\\n\"", ";", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "InstructionClass", "MFMASUnits", "(", "isMFMAFn", ",", "MFMAGroupMaxSize", ")", ";", "const", "IsInstructionType", "isVMEMReadFn", "=", "[", "this", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "(", "(", "TII", "->", "isFLAT", "(", "MI", ")", "&&", "!", "TII", "->", "isDS", "(", "MI", ")", ")", "||", "TII", "->", "isVMEM", "(", "MI", ")", ")", "&&", "MI", ".", "mayLoad", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found VMEM read\\n\"", ";", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "InstructionClass", "VMEMReadSUnits", "(", "isVMEMReadFn", ",", "VMEMGroupMaxSize", ")", ";", "const", "IsInstructionType", "isDSWriteFn", "=", "[", "this", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "TII", "->", "isDS", "(", "MI", ")", "&&", "MI", ".", "mayStore", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found DS Write\\n\"", ";", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "InstructionClass", "DSWriteSUnits", "(", "isDSWriteFn", ",", "LDWGroupMaxSize", ")", ";", "const", "IsInstructionType", "isDSReadFn", "=", "[", "this", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "TII", "->", "isDS", "(", "MI", ")", "&&", "MI", ".", "mayLoad", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found DS Read\\n\"", ";", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", ";", "InstructionClass", "DSReadSUnits", "(", "isDSReadFn", ",", "LDRGroupMaxSize", ")", ";", "SmallVector", "<", "InstructionClass", "*", ",", "4", ">", "PipelineOrder", "=", "{", "&", "VMEMReadSUnits", ",", "&", "DSReadSUnits", ",", "&", "MFMASUnits", ",", "&", "DSWriteSUnits", "}", ";", "collectSUnits", "(", "PipelineOrder", ",", "TII", ",", "DAG", ")", ";", "addPipelineEdges", "(", "PipelineOrder", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Apply", "the", "profile", "inference", "algorithm", "for", "a", "given", "function", "." ]

[ "AMDGPU", "AMDGPU::V_ACCVGPR_WRITE_B32_e64", "AMDGPU::V_ACCVGPR_READ_B32_e64", "\"Found MFMA\\n\"", "\"Found VMEM read\\n\"", "\"Found DS Write\\n\"", "\"Found DS Read\\n\"", "4" ]

[]

[ "<s>", "static", "int", "h8300_ldm_stm_regno", "(", "rtx", "x", ",", "int", "load_p", ",", "int", "index", ",", "int", "nregs", ")", "{", "int", "regindex", ",", "memindex", ",", "offset", ";", "if", "(", "load_p", ")", "regindex", "=", "0", ",", "memindex", "=", "1", ",", "offset", "=", "(", "nregs", "-", "index", "-", "1", ")", "*", "4", ";", "else", "memindex", "=", "0", ",", "regindex", "=", "1", ",", "offset", "=", "(", "index", "+", "1", ")", "*", "-", "4", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SET", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "regindex", ")", ")", "==", "REG", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "memindex", ")", ")", "==", "MEM", "&&", "h8300_stack_offset_p", "(", "XEXP", "(", "XEXP", "(", "x", ",", "memindex", ")", ",", "0", ")", ",", "offset", ")", ")", "return", "REGNO", "(", "XEXP", "(", "x", ",", "regindex", ")", ")", ";", "return", "-", "1", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "h8300_ldm_stm_parallel", ".", "X", "is", "one", "pattern", "in", "something", "that", "may", "be", "an", "ldm", "or", "stm", "instruction", ".", "If", "it", "fits", "the", "required", "template", ",", "return", "the", "register", "it", "loads", "or", "stores", ",", "otherwise", "return", "-1", ".", "LOAD_P", "is", "true", "if", "X", "should", "be", "a", "load", ",", "false", "if", "it", "should", "be", "a", "store", ".", "NREGS", "is", "the", "number", "of", "registers", "that", "the", "whole", "instruction", "is", "expected", "to", "load", "or", "store", ".", "INDEX", "is", "the", "index", "of", "the", "register", "that", "X", "should", "load", "or", "store", ",", "relative", "to", "the", "lowest-numbered", "register", "." ]

[ "h8300", "0", "1", "1", "4", "0", "1", "1", "4", "0", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"X86 Atom LEA Fixup\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Atom LEA Fixup\"" ]

[]

[ "<s>", "void", "rs6000_emit_sISEL", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "operands", "[", "]", ")", "{", "rs6000_emit_int_cmove", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "const1_rtx", ",", "const0_rtx", ")", ";", "}", "</s>" ]

[ "Emit", "the", "RTL", "for", "an", "sISEL", "pattern", "." ]

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

[]

[ "<s>", "void", "xstormy16_expand_prologue", "(", "void", ")", "{", "struct", "xstormy16_stack_layout", "layout", ";", "int", "regno", ";", "rtx", "insn", ";", "rtx", "mem_push_rtx", ";", "const", "int", "ifun", "=", "xstormy16_interrupt_function_p", "(", ")", ";", "mem_push_rtx", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "mem_push_rtx", "=", "gen_rtx_MEM", "(", "HImode", ",", "mem_push_rtx", ")", ";", "layout", "=", "xstormy16_compute_stack_layout", "(", ")", ";", "if", "(", "layout", ".", "locals_size", ">=", "32768", ")", "error", "(", "\"local variable memory requirements exceed capacity\"", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "layout", ".", "frame_size", ";", "if", "(", "layout", ".", "stdarg_save_size", ")", "for", "(", "regno", "=", "FIRST_ARGUMENT_REGISTER", ";", "regno", "<", "FIRST_ARGUMENT_REGISTER", "+", "NUM_ARGUMENT_REGISTERS", ";", "regno", "++", ")", "{", "rtx", "dwarf", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "HImode", ",", "regno", ")", ";", "insn", "=", "emit_move_insn", "(", "mem_push_rtx", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "gen_rtx_MEM", "(", "Pmode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", ")", "=", "1", ";", "}", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "REG_NEEDS_SAVE", "(", "regno", ",", "ifun", ")", ")", "{", "rtx", "dwarf", ";", "rtx", "reg", "=", "gen_rtx_REG", "(", "HImode", ",", "regno", ")", ";", "insn", "=", "emit_move_insn", "(", "mem_push_rtx", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "dwarf", "=", "gen_rtx_SEQUENCE", "(", "VOIDmode", ",", "rtvec_alloc", "(", "2", ")", ")", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", "=", "gen_rtx_SET", "(", "gen_rtx_MEM", "(", "Pmode", ",", "stack_pointer_rtx", ")", ",", "reg", ")", ";", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GET_MODE_SIZE", "(", "Pmode", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "dwarf", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "dwarf", ",", "0", ",", "0", ")", ")", "=", "1", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "dwarf", ",", "0", ",", "1", ")", ")", "=", "1", ";", "}", "if", "(", "frame_pointer_needed", "&&", "layout", ".", "sp_minus_fp", "==", "layout", ".", "locals_size", ")", "{", "insn", "=", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "layout", ".", "locals_size", ")", "{", "insn", "=", "emit_addhi3_postreload", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "layout", ".", "locals_size", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "if", "(", "frame_pointer_needed", "&&", "layout", ".", "sp_minus_fp", "!=", "layout", ".", "locals_size", ")", "{", "insn", "=", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "if", "(", "layout", ".", "sp_minus_fp", ")", "{", "insn", "=", "emit_addhi3_postreload", "(", "hard_frame_pointer_rtx", ",", "hard_frame_pointer_rtx", ",", "GEN_INT", "(", "-", "layout", ".", "sp_minus_fp", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "}", "</s>" ]

[ "Called", "after", "register", "allocation", "to", "add", "any", "instructions", "needed", "for", "the", "prologue", ".", "Using", "a", "prologue", "insn", "is", "favored", "compared", "to", "putting", "all", "of", "the", "instructions", "in", "the", "TARGET_ASM_FUNCTION_PROLOGUE", "macro", ",", "since", "it", "allows", "the", "scheduler", "to", "intermix", "instructions", "with", "the", "saves", "of", "the", "caller", "saved", "registers", ".", "In", "some", "cases", ",", "it", "might", "be", "necessary", "to", "emit", "a", "barrier", "instruction", "as", "the", "last", "insn", "to", "prevent", "such", "scheduling", ".", "Also", "any", "insns", "generated", "here", "should", "have", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", "so", "that", "the", "debug", "info", "generation", "code", "can", "handle", "them", "properly", "." ]

[ "stormy16", "32768", "\"local variable memory requirements exceed capacity\"", "1", "2", "0", "0", "0", "1", "0", "0", "1", "0", "1", "1", "0", "1", "2", "0", "0", "0", "1", "0", "0", "1", "0", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "tree", "tilegx_gimplify_va_arg_expr", "(", "tree", "valist", ",", "tree", "type", ",", "gimple_seq", "*", "pre_p", ",", "gimple_seq", "*", "post_p", "ATTRIBUTE_UNUSED", ")", "{", "tree", "f_args", ",", "f_skip", ";", "tree", "args", ",", "skip", ";", "HOST_WIDE_INT", "size", ",", "rsize", ";", "tree", "addr", ",", "tmp", ";", "bool", "pass_by_reference_p", ";", "f_args", "=", "TYPE_FIELDS", "(", "va_list_type_node", ")", ";", "f_skip", "=", "TREE_CHAIN", "(", "f_args", ")", ";", "args", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_args", ")", ",", "valist", ",", "f_args", ",", "NULL_TREE", ")", ";", "skip", "=", "build3", "(", "COMPONENT_REF", ",", "TREE_TYPE", "(", "f_skip", ")", ",", "valist", ",", "f_skip", ",", "NULL_TREE", ")", ";", "addr", "=", "create_tmp_var", "(", "ptr_type_node", ",", "\"va_arg\"", ")", ";", "pass_by_reference_p", "=", "pass_by_reference", "(", "NULL", ",", "TYPE_MODE", "(", "type", ")", ",", "type", ",", "false", ")", ";", "if", "(", "pass_by_reference_p", ")", "type", "=", "build_pointer_type", "(", "type", ")", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "rsize", "=", "(", "(", "size", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", "*", "UNITS_PER_WORD", ";", "if", "(", "TYPE_ALIGN", "(", "type", ")", ">", "PARM_BOUNDARY", ")", "{", "gcc_assert", "(", "STACK_BOUNDARY", "==", "PARM_BOUNDARY", "*", "2", ")", ";", "tmp", "=", "build2", "(", "BIT_AND_EXPR", ",", "sizetype", ",", "fold_convert", "(", "sizetype", ",", "unshare_expr", "(", "args", ")", ")", ",", "size_int", "(", "PARM_BOUNDARY", "/", "8", ")", ")", ";", "tmp", "=", "build2", "(", "POINTER_PLUS_EXPR", ",", "ptr_type_node", ",", "unshare_expr", "(", "args", ")", ",", "tmp", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "args", ")", ",", "tmp", ",", "pre_p", ")", ";", "}", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "unshare_expr", "(", "args", ")", ",", "rsize", ")", ";", "tmp", "=", "build2", "(", "TRUTH_AND_EXPR", ",", "boolean_type_node", ",", "build2", "(", "GT_EXPR", ",", "boolean_type_node", ",", "tmp", ",", "unshare_expr", "(", "skip", ")", ")", ",", "build2", "(", "LE_EXPR", ",", "boolean_type_node", ",", "unshare_expr", "(", "args", ")", ",", "unshare_expr", "(", "skip", ")", ")", ")", ";", "tmp", "=", "build3", "(", "COND_EXPR", ",", "ptr_type_node", ",", "tmp", ",", "build2", "(", "POINTER_PLUS_EXPR", ",", "ptr_type_node", ",", "unshare_expr", "(", "skip", ")", ",", "size_int", "(", "STACK_POINTER_OFFSET", ")", ")", ",", "unshare_expr", "(", "args", ")", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "rsize", ">", "size", ")", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "tmp", ",", "rsize", "-", "size", ")", ";", "gimplify_assign", "(", "addr", ",", "tmp", ",", "pre_p", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", "&&", "rsize", ">", "size", ")", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "addr", ",", "size", ")", ";", "else", "tmp", "=", "fold_build_pointer_plus_hwi", "(", "addr", ",", "rsize", ")", ";", "gimplify_assign", "(", "unshare_expr", "(", "args", ")", ",", "tmp", ",", "pre_p", ")", ";", "addr", "=", "fold_convert", "(", "build_pointer_type", "(", "type", ")", ",", "addr", ")", ";", "if", "(", "pass_by_reference_p", ")", "addr", "=", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "return", "build_va_arg_indirect_ref", "(", "addr", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_GIMPLIFY_VA_ARG_EXPR", ".", "Gimplify", "va_arg", "by", "updating", "the", "va_list", "structure", "VALIST", "as", "required", "to", "retrieve", "an", "argument", "of", "type", "TYPE", ",", "and", "returning", "that", "argument", ".", "ret", "=", "va_arg", "(", "VALIST", ",", "TYPE", ")", ";", "generates", "code", "equivalent", "to", ":", "paddedsize", "=", "(", "sizeof", "(", "TYPE", ")", "+", "7", ")", "&", "-8", ";", "if", "(", "(", "VALIST.__args", "+", "paddedsize", ">", "VALIST.__skip", ")", "&", "(", "VALIST.__args", "<", "=", "VALIST.__skip", ")", ")", "addr", "=", "VALIST.__skip", "+", "STACK_POINTER_OFFSET", ";", "else", "addr", "=", "VALIST.__args", ";", "VALIST.__args", "=", "addr", "+", "paddedsize", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "ret", "=", "*", "(", "TYPE", "*", ")", "(", "addr", "+", "paddedsize", "-", "sizeof", "(", "TYPE", ")", ")", ";", "else", "ret", "=", "*", "(", "TYPE", "*", ")", "addr", ";" ]

[ "tilegx", "\"va_arg\"", "1", "2", "8" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "(", "MFI", ".", "hasCalls", "(", ")", "&&", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", "||", "MFI", ".", "hasStackMap", "(", ")", "||", "MFI", ".", "hasPatchPoint", "(", ")", "||", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "insertSSPDeclarations", "(", "Module", "&", "M", ")", "const", "{", "if", "(", "Subtarget", "->", "getTargetTriple", "(", ")", ".", "isWindowsMSVCEnvironment", "(", ")", ")", "{", "M", ".", "getOrInsertGlobal", "(", "\"__security_cookie\"", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ";", "auto", "*", "SecurityCheckCookie", "=", "cast", "<", "Function", ">", "(", "M", ".", "getOrInsertFunction", "(", "\"__security_check_cookie\"", ",", "Type", "::", "getVoidTy", "(", "M", ".", "getContext", "(", ")", ")", ",", "Type", "::", "getInt8PtrTy", "(", "M", ".", "getContext", "(", ")", ")", ")", ")", ";", "SecurityCheckCookie", "->", "setCallingConv", "(", "CallingConv", "::", "Win64", ")", ";", "SecurityCheckCookie", "->", "addAttribute", "(", "1", ",", "Attribute", "::", "AttrKind", "::", "InReg", ")", ";", "return", ";", "}", "TargetLowering", "::", "insertSSPDeclarations", "(", "M", ")", ";", "}", "</s>" ]

[ "Inserts", "necessary", "declarations", "for", "SSP", "(", "stack", "protection", ")", "purpose", "." ]

[ "AArch64", "AArch64", "\"__security_cookie\"", "\"__security_check_cookie\"", "1" ]

[]

[ "<s>", "static", "void", "cortexa7_sched_reorder", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "*", "ready", ",", "int", "*", "n_readyp", ",", "int", "clock", ")", "{", "int", "i", ";", "int", "first_older_only", "=", "-", "1", ",", "first_younger", "=", "-", "1", ";", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";; sched_reorder for cycle %d with %d insns in ready list\\n\"", ",", "clock", ",", "*", "n_readyp", ")", ";", "for", "(", "i", "=", "*", "n_readyp", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "rtx_insn", "*", "insn", "=", "ready", "[", "i", "]", ";", "if", "(", "cortexa7_older_only", "(", "insn", ")", ")", "{", "first_older_only", "=", "i", ";", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";; reorder older found %d\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "break", ";", "}", "else", "if", "(", "cortexa7_younger", "(", "file", ",", "verbose", ",", "insn", ")", "&&", "first_younger", "==", "-", "1", ")", "first_younger", "=", "i", ";", "}", "if", "(", "first_younger", "==", "-", "1", ")", "{", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";; sched_reorder nothing to reorder as no younger\\n\"", ")", ";", "return", ";", "}", "if", "(", "first_older_only", "==", "-", "1", ")", "{", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";; sched_reorder nothing to reorder as no older_only\\n\"", ")", ";", "return", ";", "}", "if", "(", "verbose", ">", "5", ")", "fprintf", "(", "file", ",", "\";; cortexa7_sched_reorder insn %d before %d\\n\"", ",", "INSN_UID", "(", "ready", "[", "first_older_only", "]", ")", ",", "INSN_UID", "(", "ready", "[", "first_younger", "]", ")", ")", ";", "rtx_insn", "*", "first_older_only_insn", "=", "ready", "[", "first_older_only", "]", ";", "for", "(", "i", "=", "first_older_only", ";", "i", "<", "first_younger", ";", "i", "++", ")", "{", "ready", "[", "i", "]", "=", "ready", "[", "i", "+", "1", "]", ";", "}", "ready", "[", "i", "]", "=", "first_older_only_insn", ";", "return", ";", "}", "</s>" ]

[ "Look", "for", "an", "instruction", "that", "can", "dual", "issue", "only", "as", "an", "older", "instruction", ",", "and", "move", "it", "in", "front", "of", "any", "instructions", "that", "can", "dual-issue", "as", "younger", ",", "while", "preserving", "the", "relative", "order", "of", "all", "other", "instructions", "in", "the", "ready", "list", ".", "This", "is", "a", "hueuristic", "to", "help", "dual-issue", "in", "later", "cycles", ",", "by", "postponing", "issue", "of", "more", "flexible", "instructions", ".", "This", "heuristic", "may", "affect", "dual", "issue", "opportunities", "in", "the", "current", "cycle", "." ]

[ "arm", "1", "1", "5", "\";; sched_reorder for cycle %d with %d insns in ready list\\n\"", "1", "0", "5", "\";; reorder older found %d\\n\"", "1", "1", "5", "\";; sched_reorder nothing to reorder as no younger\\n\"", "1", "5", "\";; sched_reorder nothing to reorder as no older_only\\n\"", "5", "\";; cortexa7_sched_reorder insn %d before %d\\n\"", "1" ]

[]

[ "<s>", "static", "const", "char", "*", "rs6000_mangle_type", "(", "const_tree", "type", ")", "{", "type", "=", "TYPE_MAIN_VARIANT", "(", "type", ")", ";", "if", "(", "TREE_CODE", "(", "type", ")", "!=", "VOID_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "BOOLEAN_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "INTEGER_TYPE", "&&", "TREE_CODE", "(", "type", ")", "!=", "REAL_TYPE", ")", "return", "NULL", ";", "if", "(", "type", "==", "bool_char_type_node", ")", "return", "\"U6__boolc\"", ";", "if", "(", "type", "==", "bool_short_type_node", ")", "return", "\"U6__bools\"", ";", "if", "(", "type", "==", "pixel_type_node", ")", "return", "\"u7__pixel\"", ";", "if", "(", "type", "==", "bool_int_type_node", ")", "return", "\"U6__booli\"", ";", "if", "(", "type", "==", "bool_long_type_node", ")", "return", "\"U6__booll\"", ";", "if", "(", "TARGET_FLOAT128_TYPE", ")", "{", "if", "(", "type", "==", "ieee128_float_type_node", ")", "return", "\"U10__float128\"", ";", "if", "(", "type", "==", "ibm128_float_type_node", ")", "return", "\"g\"", ";", "if", "(", "type", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "(", "TARGET_IEEEQUAD", ")", "?", "\"U10__float128\"", ":", "\"g\"", ";", "}", "if", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_ELF", "&&", "TARGET_LONG_DOUBLE_128", "&&", "!", "TARGET_IEEEQUAD", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "AltiVec", "defines", "five", "built-in", "scalar", "types", "that", "serve", "as", "vector", "elements", ";", "we", "must", "teach", "the", "compiler", "how", "to", "mangle", "them", ".", "The", "128-bit", "floating", "point", "mangling", "is", "target-specific", "as", "well", ".", "MMA", "defines", "two", "built-in", "types", "to", "be", "used", "as", "opaque", "vector", "types", "." ]

[ "rs6000", "\"U6__boolc\"", "\"U6__bools\"", "\"u7__pixel\"", "\"U6__booli\"", "\"U6__booll\"", "\"U10__float128\"", "\"g\"", "\"U10__float128\"", "\"g\"", "\"g\"" ]

[]

[ "<s>", "void", "TeeRISCAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "TeeRISCMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "static", "void", "rs6000_emit_stack_tie", "(", "rtx", "fp", ",", "bool", "hard_frame_needed", ")", "{", "rtvec", "p", ";", "int", "i", ";", "rtx", "regs", "[", "3", "]", ";", "i", "=", "0", ";", "regs", "[", "i", "++", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ";", "if", "(", "hard_frame_needed", ")", "regs", "[", "i", "++", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "!", "(", "REGNO", "(", "fp", ")", "==", "STACK_POINTER_REGNUM", "||", "(", "hard_frame_needed", "&&", "REGNO", "(", "fp", ")", "==", "HARD_FRAME_POINTER_REGNUM", ")", ")", ")", "regs", "[", "i", "++", "]", "=", "fp", ";", "p", "=", "rtvec_alloc", "(", "i", ")", ";", "while", "(", "--", "i", ">=", "0", ")", "{", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "regs", "[", "i", "]", ")", ";", "RTVEC_ELT", "(", "p", ",", "i", ")", "=", "gen_rtx_SET", "(", "mem", ",", "const0_rtx", ")", ";", "}", "emit_insn", "(", "gen_stack_tie", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ")", ";", "}", "</s>" ]

[ "This", "ties", "together", "stack", "memory", "(", "MEM", "with", "an", "alias", "set", "of", "rs6000_sr_alias_set", ")", "and", "the", "change", "to", "the", "stack", "pointer", "." ]

[ "powerpcspe", "3", "0", "0" ]

[]

[ "<s>", "void", "MSP430InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "0", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "MSP430", "::", "GR16RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV16rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "MSP430", "::", "GR8RegClass", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "MSP430", "::", "MOV8rm", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::GR16RegClass", "MSP430::MOV16rm", "0", "MSP430::GR8RegClass", "MSP430::MOV8rm", "0", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "static", "void", "s390_optimize_register_info", "(", ")", "{", "char", "clobbered_regs", "[", "32", "]", ";", "int", "i", ";", "gcc_assert", "(", "epilogue_completed", ")", ";", "s390_regs_ever_clobbered", "(", "clobbered_regs", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "clobbered_regs", "[", "i", "]", "=", "clobbered_regs", "[", "i", "]", "&&", "!", "global_not_special_regno_p", "(", "i", ")", ";", "clobbered_regs", "[", "RETURN_REGNUM", "]", "|=", "(", "TARGET_TPF_PROFILING", "||", "cfun_frame_layout", ".", "save_return_addr_p", "||", "crtl", "->", "calls_eh_return", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "i", "++", ")", "if", "(", "!", "clobbered_regs", "[", "i", "]", "||", "call_used_regs", "[", "i", "]", ")", "cfun_gpr_save_slot", "(", "i", ")", "=", "SAVE_SLOT_NONE", ";", "s390_register_info_set_ranges", "(", ")", ";", "s390_register_info_arg_gpr", "(", ")", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "by", "s390_optimize_prologue", "in", "order", "to", "get", "rid", "of", "unnecessary", "GPR", "save/restore", "instructions", ".", "The", "register", "info", "for", "the", "GPRs", "is", "re-computed", "and", "the", "ranges", "are", "re-calculated", "." ]

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

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getMinValue", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "-", "1U", "<<", "(", "bits", "-", "1", ")", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "the", "minimal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1U", "1", "0" ]

[]

[ "<s>", "bool", "MicroMipsSizeReduce", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "static_cast", "<", "const", "MipsSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "!", "Subtarget", "->", "inMicroMipsMode", "(", ")", "||", "!", "Subtarget", "->", "hasMips32r2", "(", ")", ")", "return", "false", ";", "MipsII", "=", "static_cast", "<", "const", "MipsInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "for", "(", ";", "I", "!=", "E", ";", "++", "I", ")", "Modified", "|=", "ReduceMBB", "(", "*", "I", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "scalar_int_mode", "rs6000_abi_word_mode", "(", "void", ")", "{", "return", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "}", "</s>" ]

[ "The", "mode", "the", "ABI", "uses", "for", "a", "word", ".", "This", "is", "not", "the", "same", "as", "word_mode", "for", "-m32", "-mpowerpc64", ".", "This", "is", "used", "to", "implement", "various", "target", "hooks", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "void", "ATTRIBUTE_UNUSED", "ix86_debug_options", "(", "void", ")", "{", "char", "*", "opts", "=", "ix86_target_string", "(", "ix86_isa_flags", ",", "ix86_isa_flags2", ",", "target_flags", ",", "ix86_target_flags", ",", "ix86_arch_string", ",", "ix86_tune_string", ",", "ix86_fpmath", ",", "true", ",", "true", ")", ";", "if", "(", "opts", ")", "{", "fprintf", "(", "stderr", ",", "\"%s\\n\\n\"", ",", "opts", ")", ";", "free", "(", "opts", ")", ";", "}", "else", "fputs", "(", "\"<no options>\\n\\n\"", ",", "stderr", ")", ";", "return", ";", "}", "</s>" ]

[ "Function", "that", "is", "callable", "from", "the", "debugger", "to", "print", "the", "current", "options", "." ]

[ "i386", "\"%s\\n\\n\"", "\"<no options>\\n\\n\"" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getOpcodeAfterMemoryUnfold", "(", "unsigned", "Opc", ",", "bool", "UnfoldLoad", ",", "bool", "UnfoldStore", ",", "unsigned", "*", "LoadRegIndex", ")", "const", "{", "DenseMap", "<", "unsigned", ",", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "::", "const_iterator", "I", "=", "MemOp2RegOpTable", ".", "find", "(", "Opc", ")", ";", "if", "(", "I", "==", "MemOp2RegOpTable", ".", "end", "(", ")", ")", "return", "0", ";", "bool", "FoldedLoad", "=", "I", "->", "second", ".", "second", "&", "(", "1", "<<", "4", ")", ";", "bool", "FoldedStore", "=", "I", "->", "second", ".", "second", "&", "(", "1", "<<", "5", ")", ";", "if", "(", "UnfoldLoad", "&&", "!", "FoldedLoad", ")", "return", "0", ";", "if", "(", "UnfoldStore", "&&", "!", "FoldedStore", ")", "return", "0", ";", "if", "(", "LoadRegIndex", ")", "*", "LoadRegIndex", "=", "I", "->", "second", ".", "second", "&", "0xf", ";", "return", "I", "->", "second", ".", "first", ";", "}", "</s>" ]

[ "getOpcodeAfterMemoryUnfold", "-", "Returns", "the", "opcode", "of", "the", "would", "be", "new", "instruction", "after", "load", "/", "store", "are", "unfolded", "from", "an", "instruction", "of", "the", "specified", "opcode", "." ]

[ "X86", "X86", "0", "1", "4", "1", "5", "0", "0", "0xf" ]

[]

[ "<s>", "outliner", "::", "OutlinedFunction", "X86InstrInfo", "::", "getOutliningCandidateInfo", "(", "std", "::", "vector", "<", "outliner", "::", "Candidate", ">", "&", "RepeatedSequenceLocs", ")", "const", "{", "unsigned", "SequenceSize", "=", "std", "::", "accumulate", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "front", "(", ")", ",", "std", "::", "next", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", ")", ",", "0", ",", "[", "]", "(", "unsigned", "Sum", ",", "const", "MachineInstr", "&", "MI", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isKill", "(", ")", ")", "return", "Sum", ";", "return", "Sum", "+", "1", ";", "}", ")", ";", "unsigned", "CFICount", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "RepeatedSequenceLocs", "[", "0", "]", ".", "front", "(", ")", ";", "for", "(", "unsigned", "Loc", "=", "RepeatedSequenceLocs", "[", "0", "]", ".", "getStartIdx", "(", ")", ";", "Loc", "<", "RepeatedSequenceLocs", "[", "0", "]", ".", "getEndIdx", "(", ")", "+", "1", ";", "Loc", "++", ")", "{", "if", "(", "MBBI", "->", "isCFIInstruction", "(", ")", ")", "CFICount", "++", ";", "MBBI", "++", ";", "}", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "{", "std", "::", "vector", "<", "MCCFIInstruction", ">", "CFIInstructions", "=", "C", ".", "getMF", "(", ")", "->", "getFrameInstructions", "(", ")", ";", "if", "(", "CFICount", ">", "0", "&&", "CFICount", "!=", "CFIInstructions", ".", "size", "(", ")", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "}", "if", "(", "RepeatedSequenceLocs", "[", "0", "]", ".", "back", "(", ")", "->", "isTerminator", "(", ")", ")", "{", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "MachineOutlinerTailCall", ",", "1", ")", ";", "return", "outliner", "::", "OutlinedFunction", "(", "RepeatedSequenceLocs", ",", "SequenceSize", ",", "0", ",", "MachineOutlinerTailCall", ")", ";", "}", "if", "(", "CFICount", ">", "0", ")", "return", "outliner", "::", "OutlinedFunction", "(", ")", ";", "for", "(", "outliner", "::", "Candidate", "&", "C", ":", "RepeatedSequenceLocs", ")", "C", ".", "setCallInfo", "(", "MachineOutlinerDefault", ",", "1", ")", ";", "return", "outliner", "::", "OutlinedFunction", "(", "RepeatedSequenceLocs", ",", "SequenceSize", ",", "1", ",", "MachineOutlinerDefault", ")", ";", "}", "</s>" ]

[ "Returns", "a", "outliner", ":", ":OutlinedFunction", "struct", "containing", "target-specific", "information", "for", "a", "set", "of", "outlining", "candidates", "." ]

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

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "AArch64TargetLowering", "::", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "{", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "SVT", "==", "MVT", "::", "v1i8", "||", "SVT", "==", "MVT", "::", "v1i16", "||", "SVT", "==", "MVT", "::", "v1i32", "||", "SVT", "==", "MVT", "::", "v1f32", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "AArch64", "AArch64", "MVT::v1i8", "MVT::v1i16", "MVT::v1i32", "MVT::v1f32" ]

[]

[ "<s>", "bool", "X86PassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createX86ISelDag", "(", "getX86TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "!", "getX86Subtarget", "(", ")", ".", "is64Bit", "(", ")", ")", "PM", "->", "add", "(", "createGlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]