Datasets:

---

docz1105

/

ComBack

like 9

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

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

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

[]

[ "<s>", "static", "int", "rs6000_compute_pressure_classes", "(", "enum", "reg_class", "*", "pressure_classes", ")", "{", "int", "n", ";", "n", "=", "0", ";", "pressure_classes", "[", "n", "++", "]", "=", "GENERAL_REGS", ";", "if", "(", "TARGET_VSX", ")", "pressure_classes", "[", "n", "++", "]", "=", "VSX_REGS", ";", "else", "{", "if", "(", "TARGET_ALTIVEC", ")", "pressure_classes", "[", "n", "++", "]", "=", "ALTIVEC_REGS", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", ")", "pressure_classes", "[", "n", "++", "]", "=", "FLOAT_REGS", ";", "}", "pressure_classes", "[", "n", "++", "]", "=", "CR_REGS", ";", "pressure_classes", "[", "n", "++", "]", "=", "SPECIAL_REGS", ";", "return", "n", ";", "}", "</s>" ]

[ "Compute", "register", "pressure", "classes", ".", "We", "implement", "the", "target", "hook", "to", "avoid", "IRA", "picking", "something", "like", "GEN_OR_FLOAT_REGS", "as", "a", "pressure", "class", ",", "which", "can", "lead", "to", "incorrect", "estimates", "of", "number", "of", "available", "registers", "and", "therefor", "increased", "register", "pressure/spill", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "const", "char", "*", "output_load_pcrel_sym", "(", "rtx", "*", "operands", ")", "{", "if", "(", "flag_delayed_branch", ")", "{", "output_asm_insn", "(", "\"sethi\\t%%hi(%a1-4), %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"call\\t%a2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\" add\\t%0, %%lo(%a1+4), %0\"", ",", "operands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"sethi\\t%%hi(%a1-8), %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"add\\t%0, %%lo(%a1-4), %0\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\"call\\t%a2\"", ",", "operands", ")", ";", "output_asm_insn", "(", "\" nop\"", ",", "NULL", ")", ";", "}", "if", "(", "operands", "[", "2", "]", "==", "got_helper_rtx", ")", "got_helper_needed", "=", "true", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "the", "load_pcrel_sym", "pattern", "." ]

[ "sparc", "\"sethi\\t%%hi(%a1-4), %0\"", "\"call\\t%a2\"", "\" add\\t%0, %%lo(%a1+4), %0\"", "\"sethi\\t%%hi(%a1-8), %0\"", "\"add\\t%0, %%lo(%a1-4), %0\"", "\"call\\t%a2\"", "\" nop\"", "2", "\"\"" ]

[]

[ "<s>", "static", "int", "arc_save_callee_milli", "(", "uint64_t", "gmask", ",", "bool", "save_blink", ",", "bool", "save_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "reg_size", ")", "{", "int", "start_reg", "=", "13", ";", "int", "end_reg", "=", "25", ";", "int", "regno", ",", "indx", ",", "off", ",", "nregs", ";", "rtx", "insn", ",", "reg", ",", "mem", ";", "int", "frame_allocated", "=", "0", ";", "for", "(", "regno", "=", "start_reg", ";", "regno", "<=", "end_reg", "&&", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", ";", ")", "regno", "++", ";", "end_reg", "=", "regno", "-", "1", ";", "nregs", "=", "end_reg", "-", "start_reg", "+", "1", ";", "gcc_assert", "(", "end_reg", ">", "14", ")", ";", "if", "(", "save_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_allocated", "+=", "frame_save_reg", "(", "reg", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "if", "(", "reg_size", "||", "offset", ")", "{", "frame_stack_add", "(", "offset", "-", "reg_size", ")", ";", "frame_allocated", "+=", "nregs", "*", "UNITS_PER_WORD", "-", "offset", ";", "offset", "=", "0", ";", "}", "insn", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "rtvec_alloc", "(", "nregs", "+", "1", ")", ")", ";", "indx", "=", "0", ";", "XVECEXP", "(", "insn", ",", "0", ",", "nregs", ")", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "indx", "=", "0", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "indx", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", "=", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "XVECEXP", "(", "insn", ",", "0", ",", "indx", ")", ")", "=", "1", ";", "gmask", "=", "gmask", "&", "~", "(", "1ULL", "<<", "regno", ")", ";", "}", "insn", "=", "frame_insn", "(", "insn", ")", ";", "for", "(", "regno", "=", "start_reg", ",", "off", "=", "0", ";", "regno", "<=", "end_reg", ";", "regno", "++", ",", "off", "+=", "UNITS_PER_WORD", ")", "{", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_OFFSET", ",", "gen_rtx_SET", "(", "mem", ",", "reg", ")", ")", ";", "}", "if", "(", "arc_must_save_return_addr", "(", "cfun", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "reg_size", ")", ")", ")", ")", ";", "}", "for", "(", "regno", "=", "0", ";", "regno", "<=", "GMASK_LEN", ";", "regno", "++", ")", "{", "if", "(", "(", "gmask", "&", "(", "1ULL", "<<", "regno", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "mem", "=", "gen_frame_mem", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "off", ")", ")", ";", "frame_move_inc", "(", "mem", ",", "reg", ",", "stack_pointer_rtx", ",", "0", ")", ";", "frame_allocated", "+=", "UNITS_PER_WORD", ";", "off", "+=", "UNITS_PER_WORD", ";", "}", "if", "(", "save_fp", ")", "frame_allocated", "+=", "frame_save_reg", "(", "hard_frame_pointer_rtx", ",", "offset", ")", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", ")", "frame_move", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ";", "return", "frame_allocated", ";", "}", "</s>" ]

[ "Millicode", "thunks", "implementation", ":", "Generates", "calls", "to", "millicodes", "for", "registers", "starting", "from", "r13", "to", "r25", "Present", "Limitations", ":", "-", "Only", "one", "range", "supported", ".", "The", "remaining", "regs", "will", "have", "the", "ordinary", "st", "and", "ld", "instructions", "for", "store", "and", "loads", ".", "Hence", "a", "gmask", "asking", "to", "store", "r13-14", ",", "r16-r25", "will", "only", "generate", "calls", "to", "store", "and", "load", "r13", "to", "r14", "while", "store", "and", "load", "insns", "will", "be", "generated", "for", "r16", "to", "r25", "in", "the", "prologue", "and", "epilogue", "respectively", ".", "-", "Presently", "library", "only", "supports", "register", "ranges", "starting", "from", "r13", "." ]

[ "arc", "13", "25", "0", "1ULL", "1", "1", "14", "0", "0", "1", "0", "0", "0", "0", "0", "0", "1", "1ULL", "0", "0", "1ULL", "0", "0" ]

[]

[ "<s>", "bool", "AAPPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createAAPISelDag", "(", "getAAPTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AAP", "AAP", "AAP", "AAP" ]

[]

[ "<s>", "bool", "ARCAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "ensureAlignment", "(", "Align", "(", "4", ")", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "4" ]

[]

[ "<s>", "static", "bool", "reg_offset_addressing_ok_p", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V16QImode", ":", "case", "E_V8HImode", ":", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "case", "E_V1TImode", ":", "case", "E_TImode", ":", "case", "E_TFmode", ":", "case", "E_KFmode", ":", "if", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", ")", "return", "mode_supports_vsx_dform_quad", "(", "mode", ")", ";", "break", ";", "case", "E_V4HImode", ":", "case", "E_V2SImode", ":", "case", "E_V1DImode", ":", "case", "E_V2SFmode", ":", "if", "(", "TARGET_PAIRED_FLOAT", ")", "return", "false", ";", "break", ";", "case", "E_SDmode", ":", "if", "(", "TARGET_NO_SDMODE_STACK", ")", "return", "false", ";", "break", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Subroutines", "of", "rs6000_legitimize_address", "and", "rs6000_legitimate_address_p", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32argRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64argRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64common_and_GPR64noipRegClassID", ":", "case", "AArch64", "::", "GPR64noip_and_tcGPR64RegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32argRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64argRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64noipRegClassID", "AArch64::GPR64common_and_GPR64noipRegClassID", "AArch64::GPR64noip_and_tcGPR64RegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "bool", "AArch64PreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "&", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "AArch64PreLegalizerCombinerInfo", "PCInfo", ";", "Combiner", "C", "(", "PCInfo", ",", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "d30v_issue_rate", "(", ")", "{", "return", "2", ";", "}", "</s>" ]

[ "Function", "which", "returns", "the", "number", "of", "insns", "that", "can", "be", "scheduled", "in", "the", "same", "machine", "cycle", ".", "This", "must", "be", "constant", "over", "an", "entire", "compilation", ".", "The", "default", "is", "1", "." ]

[ "d30v", "2" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "if", "(", "!", "CurrCycleInstr", ")", "return", ";", "if", "(", "CurrCycleInstr", "->", "isImplicitDef", "(", ")", "||", "CurrCycleInstr", "->", "isDebugInstr", "(", ")", "||", "CurrCycleInstr", "->", "isKill", "(", ")", ")", "return", ";", "unsigned", "NumWaitStates", "=", "TII", ".", "getNumWaitStates", "(", "*", "CurrCycleInstr", ")", ";", "EmittedInstrs", ".", "push_front", "(", "CurrCycleInstr", ")", ";", "for", "(", "unsigned", "i", "=", "1", ",", "e", "=", "std", "::", "min", "(", "NumWaitStates", ",", "getMaxLookAhead", "(", ")", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "EmittedInstrs", ".", "push_front", "(", "nullptr", ")", ";", "}", "EmittedInstrs", ".", "resize", "(", "getMaxLookAhead", "(", ")", ")", ";", "CurrCycleInstr", "=", "nullptr", ";", "}", "</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", "." ]

[ "AMDGPU", "1" ]

[]

[ "<s>", "Align", "getABIAlignmentForCallingConv", "(", "Type", "*", "ArgTy", ",", "const", "DataLayout", "&", "DL", ")", "const", "override", "{", "const", "Align", "ABIAlign", "=", "DL", ".", "getABITypeAlign", "(", "ArgTy", ")", ";", "if", "(", "ArgTy", "->", "isVectorTy", "(", ")", ")", "return", "std", "::", "min", "(", "ABIAlign", ",", "Align", "(", "8", ")", ")", ";", "return", "ABIAlign", ";", "}", "</s>" ]

[ "Return", "the", "correct", "alignment", "for", "the", "current", "calling", "convention", "." ]

[ "Mips", "8" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFreeAddrSpaceCast", "(", "unsigned", "SrcAS", ",", "unsigned", "DestAS", ")", "const", "{", "if", "(", "SrcAS", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ")", "return", "true", ";", "return", "isNoopAddrSpaceCast", "(", "SrcAS", ",", "DestAS", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "a", "cast", "from", "SrcAS", "to", "DestAS", "is", "``", "cheap", "''", ",", "such", "that", "e.g", "." ]

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

[]

[ "<s>", "bool", "CAHPAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "Res", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "Res", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "ErrorLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "CAHPOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "CAHPOperand", "&", "Operand", "=", "(", "CAHPOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ";", "if", "(", "!", "Operand", ".", "isImm", "(", ")", ")", "return", "Error", "(", "Operand", ".", "getStartLoc", "(", ")", ",", "\"invalid operand for instruction\"", ")", ";", "switch", "(", "Res", ")", "{", "case", "Match_InvalidSImm", "##", "nbits", ":", "\\", "return", "generateImmOutOfRangeError", "(", "\\", "Operands", ",", "ErrorInfo", ",", "-", "(", "1", "<<", "(", "nbits", "-", "1", ")", ")", ",", "(", "1", "<<", "(", "nbits", "-", "1", ")", ")", "-", "1", ")", ";", "case", "Match_InvalidUImm", "##", "nbits", ":", "\\", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "0", ",", "(", "1", "<<", "nbits", ")", "-", "1", ")", ";", "case", "Match_InvalidSImm", "##", "nbits", "##", "Lsb0", ":", "\\", "return", "generateImmOutOfRangeError", "(", "\\", "Operands", ",", "ErrorInfo", ",", "-", "(", "1", "<<", "(", "nbits", "-", "1", ")", ")", ",", "(", "1", "<<", "(", "nbits", "-", "1", ")", ")", "-", "2", ",", "\\", "\"immediate must be a multiple of 2 bytes in the range\"", ")", ";", "case", "Match_InvalidUImm", "##", "nbits", "##", "Lsb0", ":", "\\", "return", "generateImmOutOfRangeError", "(", "\\", "Operands", ",", "ErrorInfo", ",", "0", ",", "(", "1", "<<", "nbits", ")", "-", "2", ",", "\\", "\"immediate must be a multiple of 2 bytes in the range\"", ")", ";", "CASE_MATCH_INVALID_UIMM", "(", "4", ")", ";", "CASE_MATCH_INVALID_SIMM", "(", "11", ")", ";", "CASE_MATCH_INVALID_UIMM_LSB0", "(", "7", ")", ";", "case", "Match_InvalidSImm6", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "-", "(", "1", "<<", "5", ")", ",", "(", "1", "<<", "5", ")", "-", "1", ",", "\"operand must be a symbol with %hi modifier or an integer in \"", "\"the range\"", ")", ";", "case", "Match_InvalidSImm10", ":", "return", "generateImmOutOfRangeError", "(", "Operands", ",", "ErrorInfo", ",", "-", "(", "1", "<<", "9", ")", ",", "(", "1", "<<", "9", ")", "-", "1", ",", "\"operand must be a symbol with %lo modifier or an integer in \"", "\"the range\"", ")", ";", "}", "llvm_unreachable", "(", "\"Unknown match type detected!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "CAHP", "CAHP", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "CAHP", "\"invalid operand for instruction\"", "CAHP", "CAHP", "\"invalid operand for instruction\"", "1", "1", "1", "1", "1", "0", "1", "1", "1", "1", "1", "1", "2", "\"immediate must be a multiple of 2 bytes in the range\"", "0", "1", "2", "\"immediate must be a multiple of 2 bytes in the range\"", "4", "11", "7", "1", "5", "1", "5", "1", "\"operand must be a symbol with %hi modifier or an integer in \"", "\"the range\"", "1", "9", "1", "9", "1", "\"operand must be a symbol with %lo modifier or an integer in \"", "\"the range\"", "\"Unknown match type detected!\"" ]

[]

[ "<s>", "Cpu0ExprKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "const", "NVPTXInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPostRegAlloc", "(", ")", "{", "addPass", "(", "createX86FloatingPointStackifierPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createX86LoadValueInjectionLoadHardeningPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"MCS51 Shift Expansion\"", ";", "}", "</s>" ]

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

[ "MCS51", "\"MCS51 Shift Expansion\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "SystemZRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "SystemZSubtarget", "*", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "SystemZCallingConventionRegisters", "*", "Regs", "=", "Subtarget", "->", "getSpecialRegisters", "(", ")", ";", "return", "Regs", "->", "getCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "MipsAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ParseInstruction\\n\"", ")", ";", "if", "(", "!", "mnemonicIsValid", "(", "Name", ",", "0", ")", ")", "{", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "NameLoc", ",", "\"Unknown instruction\"", ")", ";", "}", "Operands", ".", "push_back", "(", "MipsOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ",", "*", "this", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", "&&", "ParseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ",", "Name", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LBrac", ")", ")", "{", "if", "(", "ParseBracketSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "else", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "LParen", ")", "&&", "ParseParenSuffix", "(", "Name", ",", "Operands", ")", ")", "return", "true", ";", "}", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token in argument list\"", ")", ";", "}", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "\"ParseInstruction\\n\"", "0", "\"Unknown instruction\"", "MipsOperand::CreateToken", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"", "\"unexpected token in argument list\"" ]

[]

[ "<s>", "bool", "TPCAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "ExtraCode", "||", "!", "ExtraCode", "[", "0", "]", ")", "{", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "}", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "0" ]

[]

[ "<s>", "static", "void", "query", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "&", "AA", ",", "bool", "&", "Read", ",", "bool", "&", "Write", ",", "bool", "&", "Effects", ",", "bool", "&", "StackPointer", ")", "{", "assert", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "!", "MI", ".", "isDereferenceableInvariantLoad", "(", "&", "AA", ")", ")", "Read", "=", "true", ";", "if", "(", "MI", ".", "mayStore", "(", ")", ")", "{", "Write", "=", "true", ";", "}", "else", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "{", "Write", "=", "true", ";", "Effects", "=", "true", ";", "}", "break", ";", "}", "}", "if", "(", "MI", ".", "hasUnmodeledSideEffects", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "Effects", "=", "true", ";", "break", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "GLOBAL_SET_I32", "&&", "strcmp", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "StackPointer", "=", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "{", "queryCallee", "(", "MI", ",", "Read", ",", "Write", ",", "Effects", ",", "StackPointer", ")", ";", "}", "}", "</s>" ]

[ "Query", "a", "line", "of", "the", "assigned", "virtual", "register", "matrix", "directly", "." ]

[ "WebAssembly", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::GLOBAL_SET_I32", "0", "\"__stack_pointer\"", "0" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "M", ")", "override", "{", "SMShadowTracker", ".", "reset", "(", "0", ")", ";", "SM", ".", "reset", "(", ")", ";", "FM", ".", "reset", "(", ")", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "X86", "0" ]

[]

[ "<s>", "static", "void", "s390_restore_gprs_from_fprs", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_Z10", "||", "!", "TARGET_HARD_FLOAT", "||", "!", "crtl", "->", "is_leaf", ")", "return", ";", "for", "(", "i", "=", "STACK_POINTER_REGNUM", ";", "i", ">=", "6", ";", "i", "--", ")", "{", "rtx_insn", "*", "insn", ";", "if", "(", "!", "FP_REGNO_P", "(", "cfun_gpr_save_slot", "(", "i", ")", ")", ")", "continue", ";", "rtx", "fpr", "=", "gen_rtx_REG", "(", "DImode", ",", "cfun_gpr_save_slot", "(", "i", ")", ")", ";", "if", "(", "i", "==", "STACK_POINTER_REGNUM", ")", "insn", "=", "emit_insn", "(", "gen_stack_restore_from_fpr", "(", "fpr", ")", ")", ";", "else", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "i", ")", ",", "fpr", ")", ";", "df_set_regs_ever_live", "(", "i", ",", "true", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "DImode", ",", "i", ")", ")", ";", "if", "(", "i", "==", "STACK_POINTER_REGNUM", "||", "i", "==", "HARD_FRAME_POINTER_REGNUM", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "STACK_POINTER_OFFSET", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Restore", "GPRs", "from", "FPR", "save", "slots", "." ]

[ "s390", "6", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"Lanai Delay Slot Filler\"", ";", "}", "</s>" ]

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

[ "Lanai", "\"Lanai Delay Slot Filler\"" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "LLT", "PtrTy", "=", "LLT", "::", "pointer", "(", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ",", "32", ")", ";", "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "32", ")", ";", "if", "(", "IsTailCall", ")", "{", "llvm_unreachable", "(", "\"implement me\"", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "SPReg", ")", "SPReg", "=", "MIRBuilder", ".", "buildCopy", "(", "PtrTy", ",", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "getReg", "(", "0", ")", ";", "auto", "OffsetReg", "=", "MIRBuilder", ".", "buildConstant", "(", "S32", ",", "Offset", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildPtrAdd", "(", "PtrTy", ",", "SPReg", ",", "OffsetReg", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getStack", "(", "MF", ",", "Offset", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

[ "AMDGPU", "AMDGPU", "32", "32", "\"implement me\"", "SI", "SI", "0", "0" ]

[]

[ "<s>", "void", "ARMCallLowering", "::", "splitToValueTypes", "(", "const", "ArgInfo", "&", "OrigArg", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "SplitArgs", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "ARMTargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "LLVMContext", "&", "Ctx", "=", "OrigArg", ".", "Ty", "->", "getContext", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "EVT", ",", "4", ">", "SplitVTs", ";", "ComputeValueVTs", "(", "TLI", ",", "DL", ",", "OrigArg", ".", "Ty", ",", "SplitVTs", ",", "nullptr", ",", "nullptr", ",", "0", ")", ";", "assert", "(", "OrigArg", ".", "Regs", ".", "size", "(", ")", "==", "SplitVTs", ".", "size", "(", ")", "&&", "\"Regs / types mismatch\"", ")", ";", "if", "(", "SplitVTs", ".", "size", "(", ")", "==", "1", ")", "{", "auto", "Flags", "=", "OrigArg", ".", "Flags", "[", "0", "]", ";", "Flags", ".", "setOrigAlign", "(", "DL", ".", "getABITypeAlign", "(", "OrigArg", ".", "Ty", ")", ")", ";", "SplitArgs", ".", "emplace_back", "(", "OrigArg", ".", "Regs", "[", "0", "]", ",", "SplitVTs", "[", "0", "]", ".", "getTypeForEVT", "(", "Ctx", ")", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "return", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "SplitVTs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "SplitVT", "=", "SplitVTs", "[", "i", "]", ";", "Type", "*", "SplitTy", "=", "SplitVT", ".", "getTypeForEVT", "(", "Ctx", ")", ";", "auto", "Flags", "=", "OrigArg", ".", "Flags", "[", "0", "]", ";", "Flags", ".", "setOrigAlign", "(", "DL", ".", "getABITypeAlign", "(", "SplitTy", ")", ")", ";", "bool", "NeedsConsecutiveRegisters", "=", "TLI", ".", "functionArgumentNeedsConsecutiveRegisters", "(", "SplitTy", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "if", "(", "NeedsConsecutiveRegisters", ")", "{", "Flags", ".", "setInConsecutiveRegs", "(", ")", ";", "if", "(", "i", "==", "e", "-", "1", ")", "Flags", ".", "setInConsecutiveRegsLast", "(", ")", ";", "}", "Register", "PartReg", "=", "OrigArg", ".", "Regs", "[", "i", "]", ";", "SplitArgs", ".", "emplace_back", "(", "PartReg", ",", "SplitTy", ",", "Flags", ",", "OrigArg", ".", "IsFixed", ")", ";", "}", "}", "</s>" ]

[ "Break", "OrigArgInfo", "into", "one", "or", "more", "pieces", "the", "calling", "convention", "can", "process", ",", "returned", "in", "SplitArgs", "." ]

[ "ARM", "ARM", "ARM", "ARM", "4", "0", "\"Regs / types mismatch\"", "1", "0", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "SDValue", "VECustomDAG", "::", "getConstant", "(", "uint64_t", "Val", ",", "EVT", "VT", ",", "bool", "IsTarget", ",", "bool", "IsOpaque", ")", "const", "{", "return", "DAG", ".", "getConstant", "(", "Val", ",", "DL", ",", "VT", ",", "IsTarget", ",", "IsOpaque", ")", ";", "}", "</s>" ]

[ "Return", "the", "large", "constant", "at", "the", "given", "index", "." ]

[ "VE", "VECustomDAG::getConstant" ]

[]

[ "<s>", "static", "void", "write_omp_entry", "(", "FILE", "*", "file", ",", "const", "char", "*", "name", ",", "const", "char", "*", "orig", ")", "{", "static", "bool", "gomp_nvptx_main_declared", ";", "if", "(", "!", "gomp_nvptx_main_declared", ")", "{", "gomp_nvptx_main_declared", "=", "true", ";", "write_fn_marker", "(", "func_decls", ",", "false", ",", "true", ",", "\"gomp_nvptx_main\"", ")", ";", "func_decls", "<<", "\".extern .func gomp_nvptx_main (.param.u\"", "<<", "POINTER_SIZE", "<<", "\" %in_ar1, .param.u\"", "<<", "POINTER_SIZE", "<<", "\" %in_ar2);\\n\"", ";", "}", "(", ".", "param", ".", "u\" PS \"", "%", "arg", ",", ".", "param", ".", "u\" PS \"", "%", "stack", ",", ".", "param", ".", "u\" PS \"", "%", "sz", ")", "\\", "n", "\\", "{", "\\", "n", "\\", ".", "reg", ".", "u32", "%", "r", "<", "3", ">", ";", "\\", "n", "\\", ".", "reg", ".", "u\" PS \"", "%", "R", "<", "4", ">", ";", "\\", "n", "\\", "mov", ".", "u32", "%", "r0", ",", "%", "tid", ".", "y", ";", "\\", "n", "\\", "mov", ".", "u32", "%", "r1", ",", "\" NTID_Y \"", ";", "\\", "n", "\\", "mov", ".", "u32", "%", "r2", ",", "%", "ctaid", ".", "x", ";", "\\", "n", "\\", "cvt", ".", "u\" PS \"", ".", "u32", "%", "R1", ",", "%", "r0", ";", "\\", "n", "\\", "\" MAD_PS_32 \"", "%", "R1", ",", "%", "r1", ",", "%", "r2", ",", "%", "R1", ";", "\\", "n", "\\", "mov", ".", "u\" PS \"", "%", "R0", ",", "__nvptx_stacks", ";", "\\", "n", "\\", "\" MAD_PS_32 \"", "%", "R0", ",", "%", "r0", ",", "\" PS_BYTES \"", ",", "%", "R0", ";", "\\", "n", "\\", "ld", ".", "param", ".", "u\" PS \"", "%", "R2", ",", "[", "%", "stack", "]", ";", "\\", "n", "\\", "ld", ".", "param", ".", "u\" PS \"", "%", "R3", ",", "[", "%", "sz", "]", ";", "\\", "n", "\\", "add", ".", "u\" PS \"", "%", "R2", ",", "%", "R2", ",", "%", "R3", ";", "\\", "n", "\\", "mad", ".", "lo", ".", "u\" PS \"", "%", "R2", ",", "%", "R1", ",", "%", "R3", ",", "%", "R2", ";", "\\", "n", "\\", "st", ".", "shared", ".", "u\" PS \"", "[", "%", "R0", "]", ",", "%", "R2", ";", "\\", "n", "\\", "mov", ".", "u\" PS \"", "%", "R0", ",", "__nvptx_uni", ";", "\\", "n", "\\", "\" MAD_PS_32 \"", "%", "R0", ",", "%", "r0", ",", "4", ",", "%", "R0", ";", "\\", "n", "\\", "mov", ".", "u32", "%", "r0", ",", "0", ";", "\\", "n", "\\", "st", ".", "shared", ".", "u32", "[", "%", "R0", "]", ",", "%", "r0", ";", "\\", "n", "\\", "mov", ".", "u\" PS \"", "%", "R0", ",", "\\", "0", ";", "\\", "n", "\\", "ld", ".", "param", ".", "u\" PS \"", "%", "R1", ",", "[", "%", "arg", "]", ";", "\\", "n", "\\", "{", "\\", "n", "\\", ".", "param", ".", "u\" PS \"", "%", "P", "<", "2", ">", ";", "\\", "n", "\\", "st", ".", "param", ".", "u\" PS \"", "[", "%", "P0", "]", ",", "%", "R0", ";", "\\", "n", "\\", "st", ".", "param", ".", "u\" PS \"", "[", "%", "P1", "]", ",", "%", "R1", ";", "\\", "n", "\\", "call", ".", "uni", "gomp_nvptx_main", ",", "(", "%", "P0", ",", "%", "P1", ")", ";", "\\", "n", "\\", "}", "\\", "n", "\\", "ret", ".", "uni", ";", "\\", "n", "\\", "}", "</s>" ]

[ "Emit", "kernel", "NAME", "for", "function", "ORIG", "outlined", "for", "an", "OpenMP", "'target", "'", "region", ":", "extern", "void", "gomp_nvptx_main", "(", "void", "(", "*", "fn", ")", "(", "void", "*", ")", ",", "void", "*", "fnarg", ")", ";", "void", "__attribute__", "(", "(", "kernel", ")", ")", "NAME", "(", "void", "*", "arg", ",", "char", "*", "stack", ",", "size_t", "stacksize", ")", "{", "__nvptx_stacks", "[", "tid.y", "]", "=", "stack", "+", "stacksize", "*", "(", "ctaid.x", "*", "ntid.y", "+", "tid.y", "+", "1", ")", ";", "__nvptx_uni", "[", "tid.y", "]", "=", "0", ";", "gomp_nvptx_main", "(", "ORIG", ",", "arg", ")", ";", "}", "ORIG", "itself", "should", "not", "be", "emitted", "as", "a", "PTX", ".entry", "function", "." ]

[ "nvptx", "\"gomp_nvptx_main\"", "\".extern .func gomp_nvptx_main (.param.u\"", "\" %in_ar1, .param.u\"", "\" %in_ar2);\\n\"", "3", "4", "\" NTID_Y \"", "\" MAD_PS_32 \"", "\" MAD_PS_32 \"", "\" PS_BYTES \"", "\" MAD_PS_32 \"", "4", "0", "0", "2" ]

[]

[ "<s>", "void", "mips_split_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "enum", "mips_split_type", "split_type", ")", "{", "rtx", "low_dest", ";", "gcc_checking_assert", "(", "mips_split_move_p", "(", "dest", ",", "src", ",", "split_type", ")", ")", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "GET_MODE", "(", "dest", ")", ")", ")", "mips_split_128bit_move", "(", "dest", ",", "src", ")", ";", "else", "if", "(", "FP_REG_RTX_P", "(", "dest", ")", "||", "FP_REG_RTX_P", "(", "src", ")", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", "emit_insn", "(", "gen_move_doubleword_fprdi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "DFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprdf", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V2SFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprv2sf", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V2SImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv2si", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V4HImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv4hi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "!", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "V8QImode", ")", "emit_insn", "(", "gen_move_doubleword_fprv8qi", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "TARGET_64BIT", "&&", "GET_MODE", "(", "dest", ")", "==", "TFmode", ")", "emit_insn", "(", "gen_move_doubleword_fprtf", "(", "dest", ",", "src", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "REG_P", "(", "dest", ")", "&&", "REGNO", "(", "dest", ")", "==", "MD_REG_FIRST", ")", "{", "low_dest", "=", "mips_subword", "(", "dest", ",", "false", ")", ";", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mthidi_ti", "(", "dest", ",", "mips_subword", "(", "src", ",", "true", ")", ",", "low_dest", ")", ")", ";", "else", "emit_insn", "(", "gen_mthisi_di", "(", "dest", ",", "mips_subword", "(", "src", ",", "true", ")", ",", "low_dest", ")", ")", ";", "}", "else", "if", "(", "REG_P", "(", "src", ")", "&&", "REGNO", "(", "src", ")", "==", "MD_REG_FIRST", ")", "{", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "false", ")", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "if", "(", "TARGET_64BIT", ")", "emit_insn", "(", "gen_mfhidi_ti", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "src", ")", ")", ";", "else", "emit_insn", "(", "gen_mfhisi_di", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "src", ")", ")", ";", "}", "else", "{", "low_dest", "=", "mips_subword", "(", "dest", ",", "false", ")", ";", "if", "(", "REG_P", "(", "low_dest", ")", "&&", "reg_overlap_mentioned_p", "(", "low_dest", ",", "src", ")", ")", "{", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "mips_subword", "(", "src", ",", "true", ")", ")", ";", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "}", "else", "{", "mips_emit_move", "(", "low_dest", ",", "mips_subword", "(", "src", ",", "false", ")", ")", ";", "mips_emit_move", "(", "mips_subword", "(", "dest", ",", "true", ")", ",", "mips_subword", "(", "src", ",", "true", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Split", "a", "move", "from", "SRC", "to", "DEST", ",", "given", "that", "mips_split_move_p", "holds", ".", "SPLIT_TYPE", "describes", "the", "split", "condition", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "TM", ".", "getTargetData", "(", ")", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "EmitFunctionStubs", "(", "Stubs", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "const", "std", "::", "vector", "<", "Function", "*", ">", "&", "Personalities", "=", "MMI", "->", "getPersonalities", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "Function", "*", ">", "::", "const_iterator", "I", "=", "Personalities", ".", "begin", "(", ")", ",", "E", "=", "Personalities", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "*", "I", ")", "{", "MCSymbol", "*", "NLPSym", "=", "GetSymbolWithGlobalValueBase", "(", "*", "I", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Mang", "->", "getSymbol", "(", "*", "I", ")", ",", "true", ")", ";", "}", "}", "}", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", ".", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "else", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetHiddenGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", ".", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "0", "PPC", "8", "4", "0", "PPC", "3", "2", "0", "PPC", "8", "4", "0" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "(", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ")", ";", "++", "i", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ",", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "0", "]", ")", "->", "getLocRange", "(", ")", ")", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "case", "Match_ImmRange0_15", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,15]\"", ")", ";", "}", "case", "Match_ImmRange0_239", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,239]\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "ARM", "ARM", "\"deprecated instruction in IT block\"", "ARM::ITasm", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "ARM", "0", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "ARM", "\"immediate operand must be in the range [0,15]\"", "ARM", "\"immediate operand must be in the range [0,239]\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "ARMLowOverheadLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ".", "hasLOB", "(", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ARM Loops on \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\" ------------- \\n\"", ")", ";", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "BBUtils", "=", "std", "::", "unique_ptr", "<", "ARMBasicBlockUtils", ">", "(", "new", "ARMBasicBlockUtils", "(", "MF", ")", ")", ";", "BBUtils", "->", "computeAllBlockSizes", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "ML", ":", "MLI", ")", "{", "if", "(", "!", "ML", "->", "getParentLoop", "(", ")", ")", "Changed", "|=", "ProcessLoop", "(", "ML", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"ARM Loops on \"", "\" ------------- \\n\"", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "PowerPC" ]

[]

[ "<s>", "bool", "mips_pad_reg_upward", "(", "machine_mode", "mode", ",", "tree", "type", ")", "{", "if", "(", "type", "!=", "0", "?", "FLOAT_TYPE_P", "(", "type", ")", ":", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "!", "BYTES_BIG_ENDIAN", ";", "return", "mips_function_arg_padding", "(", "mode", ",", "type", ")", "==", "PAD_UPWARD", ";", "}", "</s>" ]

[ "Likewise", "BLOCK_REG_PADDING", "(", "MODE", ",", "TYPE", ",", "...", ")", ".", "Return", "!", "BYTES_BIG_ENDIAN", "if", "the", "least", "significant", "byte", "of", "the", "register", "has", "useful", "data", ".", "Return", "the", "opposite", "if", "the", "most", "significant", "byte", "does", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "bool", "fault_first_load_p", "(", "rtx_insn", "*", "rinsn", ")", "{", "return", "recog_memoized", "(", "rinsn", ")", ">=", "0", "&&", "get_attr_type", "(", "rinsn", ")", "==", "TYPE_VLDFF", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "instruction", "is", "fault", "first", "load", "instruction", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "BPFFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

[ "<s>", "static", "bool", "z8k_legitimate_address_p", "(", "enum", "machine_mode", "mode", ",", "rtx", "operand", ",", "bool", "strict", ")", "{", "if", "(", "REG_P", "(", "operand", ")", "&&", "z8k_reg_ok_for_base_p", "(", "operand", ")", ")", "return", "true", ";", "if", "(", "data_ref_p", "(", "operand", ")", ")", "return", "true", ";", "if", "(", "inside_ba_p", "(", "operand", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "operand", ")", "==", "PRE_DEC", "&&", "mode", "==", "HImode", "&&", "REGNO", "(", "XEXP", "(", "operand", ",", "0", ")", ")", "==", "STACK_POINTER_REGNUM", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "operand", ")", "==", "PRE_DEC", "&&", "mode", "==", "HImode", "&&", "z8k_reg_ok_for_base_p", "(", "XEXP", "(", "operand", ",", "0", ")", ")", ")", "return", "true", ";", "if", "(", "inside_x_p", "(", "operand", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", "&&", "inside_bx_p", "(", "operand", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "in", "any", "mode", "the", "z8k", "allows", "*", "(", "reg", ")", "eg", "ld", "r0", ",", "(", "r0", ")", "*", "(", "da", ")", "eg", "ld", "r0", ",", "foo", "*", "(", "reg+disp", ")", "eg", "ld", "r0", ",", "rr2", "(", "#", "8", ")", "*", "(", "pre-dec", "of", "the", "sp", ")", "eg", "push", "sp", ",", "#", "9", "*", "*", "in", "non", "huge", "mode", "we", "can", "also", "*", "(", "pre-dec", "of", "any", "reg", ")", "eg", "push", "r0", ",", "#", "9", "*", "(", "address+reg", ")", "eg", "ld", "r0", ",", "address", "(", "r0", ")", "*", "in", "small", "mode", "*", "(", "reg+reg", ")", "eg", "ld", "r0", ",", "r1", "(", "r0", ")", "*", "*" ]

[ "z8k", "0", "0", "4" ]

[]

[ "<s>", "ARMTargetLowering", "::", "ConstraintType", "ARMTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'l'", ":", "return", "C_RegisterClass", ";", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'h'", ":", "return", "C_RegisterClass", ";", "case", "'x'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "return", "C_RegisterClass", ";", "case", "'j'", ":", "return", "C_Other", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'U'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "ARM", "ARM", "ARM", "1", "0", "2", "0" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getByValTypeAlignment", "(", "const", "Type", "*", "Ty", ")", "const", "{", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", ")", "{", "unsigned", "TyAlign", "=", "TD", "->", "getABITypeAlignment", "(", "Ty", ")", ";", "if", "(", "TyAlign", ">", "8", ")", "return", "TyAlign", ";", "return", "8", ";", "}", "unsigned", "Align", "=", "4", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "getMaxByValAlign", "(", "Ty", ",", "Align", ")", ";", "return", "Align", ";", "}", "</s>" ]

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

[ "X86", "X86", "8", "8", "4" ]

[]

[ "<s>", "void", "CSKYInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "CSKYMachineFunctionInfo", "*", "CFI", "=", "MF", ".", "getInfo", "<", "CSKYMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "CSKY", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "ST32W", ";", "}", "else", "if", "(", "CSKY", "::", "CARRYRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opcode", "=", "CSKY", "::", "SPILL_CARRY", ";", "CFI", "->", "setSpillsCR", "(", ")", ";", "}", "else", "if", "(", "v2sf", "&&", "CSKY", "::", "sFPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "FST_S", ";", "else", "if", "(", "v2df", "&&", "CSKY", "::", "sFPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "FST_D", ";", "else", "if", "(", "v3sf", "&&", "CSKY", "::", "FPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "f2FST_S", ";", "else", "if", "(", "v3df", "&&", "CSKY", "::", "FPR64RegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "CSKY", "::", "f2FST_D", ";", "else", "{", "llvm_unreachable", "(", "\"Unknown RegisterClass\"", ")", ";", "}", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlign", "(", "FI", ")", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "IsKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY", "CSKY", "0", "CSKY::GPRRegClass", "CSKY::ST32W", "CSKY::CARRYRegClass", "CSKY::SPILL_CARRY", "CSKY::sFPR32RegClass", "CSKY::FST_S", "CSKY::sFPR64RegClass", "CSKY::FST_D", "CSKY::FPR32RegClass", "CSKY::f2FST_S", "CSKY::FPR64RegClass", "CSKY::f2FST_D", "\"Unknown RegisterClass\"", "0" ]

[]

[ "<s>", "void", "SystemZTargetLowering", "::", "LowerOperationWrapper", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ATOMIC_LOAD", ":", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Untyped", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", "}", ";", "MachineMemOperand", "*", "MMO", "=", "cast", "<", "AtomicSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getMemIntrinsicNode", "(", "SystemZISD", "::", "ATOMIC_LOAD_128", ",", "DL", ",", "Tys", ",", "Ops", ",", "MVT", "::", "i128", ",", "MMO", ")", ";", "Results", ".", "push_back", "(", "lowerGR128ToI128", "(", "DAG", ",", "Res", ")", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "1", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "ATOMIC_STORE", ":", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "0", ")", ",", "lowerI128ToGR128", "(", "DAG", ",", "N", "->", "getOperand", "(", "2", ")", ")", ",", "N", "->", "getOperand", "(", "1", ")", "}", ";", "MachineMemOperand", "*", "MMO", "=", "cast", "<", "AtomicSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getMemIntrinsicNode", "(", "SystemZISD", "::", "ATOMIC_STORE_128", ",", "DL", ",", "Tys", ",", "Ops", ",", "MVT", "::", "i128", ",", "MMO", ")", ";", "if", "(", "cast", "<", "AtomicSDNode", ">", "(", "N", ")", "->", "getSuccessOrdering", "(", ")", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "Res", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "SystemZ", "::", "Serialize", ",", "DL", ",", "MVT", "::", "Other", ",", "Res", ")", ",", "0", ")", ";", "Results", ".", "push_back", "(", "Res", ")", ";", "break", ";", "}", "case", "ISD", "::", "ATOMIC_CMP_SWAP_WITH_SUCCESS", ":", "{", "SDLoc", "DL", "(", "N", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "Untyped", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "0", ")", ",", "N", "->", "getOperand", "(", "1", ")", ",", "lowerI128ToGR128", "(", "DAG", ",", "N", "->", "getOperand", "(", "2", ")", ")", ",", "lowerI128ToGR128", "(", "DAG", ",", "N", "->", "getOperand", "(", "3", ")", ")", "}", ";", "MachineMemOperand", "*", "MMO", "=", "cast", "<", "AtomicSDNode", ">", "(", "N", ")", "->", "getMemOperand", "(", ")", ";", "SDValue", "Res", "=", "DAG", ".", "getMemIntrinsicNode", "(", "SystemZISD", "::", "ATOMIC_CMP_SWAP_128", ",", "DL", ",", "Tys", ",", "Ops", ",", "MVT", "::", "i128", ",", "MMO", ")", ";", "SDValue", "Success", "=", "emitSETCC", "(", "DAG", ",", "DL", ",", "Res", ".", "getValue", "(", "1", ")", ",", "SystemZ", "::", "CCMASK_CS", ",", "SystemZ", "::", "CCMASK_CS_EQ", ")", ";", "Success", "=", "DAG", ".", "getZExtOrTrunc", "(", "Success", ",", "DL", ",", "N", "->", "getValueType", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "lowerGR128ToI128", "(", "DAG", ",", "Res", ")", ")", ";", "Results", ".", "push_back", "(", "Success", ")", ";", "Results", ".", "push_back", "(", "Res", ".", "getValue", "(", "2", ")", ")", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unexpected node to lower\"", ")", ";", "}", "}", "</s>" ]

[ "This", "callback", "is", "invoked", "by", "the", "type", "legalizer", "to", "legalize", "nodes", "with", "an", "illegal", "operand", "type", "but", "legal", "result", "types", "." ]

[ "SystemZ", "SystemZ", "ISD::ATOMIC_LOAD", "MVT::Untyped", "MVT::Other", "0", "1", "SystemZISD::ATOMIC_LOAD_128", "MVT::i128", "1", "ISD::ATOMIC_STORE", "MVT::Other", "0", "2", "1", "SystemZISD::ATOMIC_STORE_128", "MVT::i128", "SystemZ::Serialize", "MVT::Other", "0", "ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS", "MVT::Untyped", "MVT::i32", "MVT::Other", "0", "1", "2", "3", "SystemZISD::ATOMIC_CMP_SWAP_128", "MVT::i128", "1", "SystemZ::CCMASK_CS", "SystemZ::CCMASK_CS_EQ", "1", "2", "\"Unexpected node to lower\"" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "ProcessInstruction", "(", "Inst", ",", "Operands", ")", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "PPCOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "PowerPC", "PPC", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "PPC", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "OptForSize", "=", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "OptimizeForSize", ")", ";", "ShouldCombineAggressively", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "<=", "CodeGenOpt", "::", "Default", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "PotentiallyNewifiableTFR", ".", "clear", "(", ")", ";", "findPotentialNewifiableTFRs", "(", "*", "BI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "BI", "->", "begin", "(", ")", ",", "End", "=", "BI", "->", "end", "(", ")", ";", "MI", "!=", "End", ";", ")", "{", "MachineInstr", "&", "I1", "=", "*", "MI", "++", ";", "if", "(", "I1", ".", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "&", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "DbgMItoMove", ".", "clear", "(", ")", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "*", "I2", ",", "MI", ",", "DoInsertAtI1", ",", "OptForSize", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "MachineBasicBlock", "*", "SIWholeQuadMode", "::", "splitBlock", "(", "MachineBasicBlock", "*", "BB", ",", "MachineInstr", "*", "TermMI", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Split block \"", "<<", "printMBBReference", "(", "*", "BB", ")", "<<", "\" @ \"", "<<", "*", "TermMI", "<<", "\"\\n\"", ")", ";", "MachineBasicBlock", "*", "SplitBB", "=", "BB", "->", "splitAt", "(", "*", "TermMI", ",", "true", ",", "LIS", ")", ";", "unsigned", "NewOpcode", "=", "0", ";", "switch", "(", "TermMI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "S_AND_B32", ":", "NewOpcode", "=", "AMDGPU", "::", "S_AND_B32_term", ";", "break", ";", "case", "AMDGPU", "::", "S_AND_B64", ":", "NewOpcode", "=", "AMDGPU", "::", "S_AND_B64_term", ";", "break", ";", "case", "AMDGPU", "::", "S_MOV_B32", ":", "NewOpcode", "=", "AMDGPU", "::", "S_MOV_B32_term", ";", "break", ";", "case", "AMDGPU", "::", "S_MOV_B64", ":", "NewOpcode", "=", "AMDGPU", "::", "S_MOV_B64_term", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "NewOpcode", ")", "TermMI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "if", "(", "SplitBB", "!=", "BB", ")", "{", "using", "DomTreeT", "=", "DomTreeBase", "<", "MachineBasicBlock", ">", ";", "SmallVector", "<", "DomTreeT", "::", "UpdateType", ",", "16", ">", "DTUpdates", ";", "for", "(", "MachineBasicBlock", "*", "Succ", ":", "SplitBB", "->", "successors", "(", ")", ")", "{", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Insert", ",", "SplitBB", ",", "Succ", "}", ")", ";", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Delete", ",", "BB", ",", "Succ", "}", ")", ";", "}", "DTUpdates", ".", "push_back", "(", "{", "DomTreeT", "::", "Insert", ",", "BB", ",", "SplitBB", "}", ")", ";", "if", "(", "MDT", ")", "MDT", "->", "getBase", "(", ")", ".", "applyUpdates", "(", "DTUpdates", ")", ";", "if", "(", "PDT", ")", "PDT", "->", "getBase", "(", ")", ".", "applyUpdates", "(", "DTUpdates", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "*", "BB", ",", "BB", "->", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_BRANCH", ")", ")", ".", "addMBB", "(", "SplitBB", ")", ";", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";", "}", "return", "SplitBB", ";", "}", "</s>" ]

[ "splitBlock", "-", "BB", "is", "split", "and", "now", "it", "has", "one", "successor", "." ]

[ "AMDGPU", "SI", "\"Split block \"", "\" @ \"", "\"\\n\"", "0", "AMDGPU::S_AND_B32", "AMDGPU::S_AND_B32_term", "AMDGPU::S_AND_B64", "AMDGPU::S_AND_B64_term", "AMDGPU::S_MOV_B32", "AMDGPU::S_MOV_B32_term", "AMDGPU::S_MOV_B64", "AMDGPU::S_MOV_B64_term", "16", "AMDGPU::S_BRANCH" ]

[]

[ "<s>", "static", "rtx", "altivec_expand_st_builtin", "(", "tree", "exp", ",", "rtx", "target", "ATTRIBUTE_UNUSED", ",", "bool", "*", "expandedp", ")", "{", "tree", "fndecl", "=", "TREE_OPERAND", "(", "TREE_OPERAND", "(", "exp", ",", "0", ")", ",", "0", ")", ";", "tree", "arglist", "=", "TREE_OPERAND", "(", "exp", ",", "1", ")", ";", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "tree", "arg0", ",", "arg1", ";", "enum", "machine_mode", "mode0", ",", "mode1", ";", "rtx", "pat", ",", "op0", ",", "op1", ";", "enum", "insn_code", "icode", ";", "switch", "(", "fcode", ")", "{", "case", "ALTIVEC_BUILTIN_ST_INTERNAL_16qi", ":", "icode", "=", "CODE_FOR_altivec_stvx_v16qi", ";", "break", ";", "case", "ALTIVEC_BUILTIN_ST_INTERNAL_8hi", ":", "icode", "=", "CODE_FOR_altivec_stvx_v8hi", ";", "break", ";", "case", "ALTIVEC_BUILTIN_ST_INTERNAL_4si", ":", "icode", "=", "CODE_FOR_altivec_stvx_v4si", ";", "break", ";", "case", "ALTIVEC_BUILTIN_ST_INTERNAL_4sf", ":", "icode", "=", "CODE_FOR_altivec_stvx_v4sf", ";", "break", ";", "default", ":", "*", "expandedp", "=", "false", ";", "return", "NULL_RTX", ";", "}", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "arg1", "=", "TREE_VALUE", "(", "TREE_CHAIN", "(", "arglist", ")", ")", ";", "op0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "op1", "=", "expand_expr", "(", "arg1", ",", "NULL_RTX", ",", "VOIDmode", ",", "0", ")", ";", "mode0", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "mode", ";", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "mode", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "0", "]", ".", "predicate", ")", "(", "op0", ",", "mode0", ")", ")", "op0", "=", "gen_rtx_MEM", "(", "mode0", ",", "copy_to_mode_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "if", "(", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "1", "]", ".", "predicate", ")", "(", "op1", ",", "mode1", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "mode1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "pat", ")", "emit_insn", "(", "pat", ")", ";", "*", "expandedp", "=", "true", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "the", "stvx", "builtins", "." ]

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

[]

[ "<s>", "static", "bool", "isEqual", "(", "const", "GCNRPTracker", "::", "LiveRegSet", "&", "S1", ",", "const", "GCNRPTracker", "::", "LiveRegSet", "&", "S2", ")", "{", "if", "(", "S1", ".", "size", "(", ")", "!=", "S2", ".", "size", "(", ")", ")", "return", "false", ";", "for", "(", "const", "auto", "&", "P", ":", "S1", ")", "{", "auto", "I", "=", "S2", ".", "find", "(", "P", ".", "first", ")", ";", "if", "(", "I", "==", "S2", ".", "end", "(", ")", "||", "I", "->", "second", "!=", "P", ".", "second", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isEqual", "-", "Compares", "two", "trees", "for", "structural", "equality", "and", "returns", "true", "if", "they", "are", "equal", "." ]

[ "AMDGPU" ]

[]

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

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

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

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "override", "{", "return", "Kind", "==", "KindTy", "::", "Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "LoongArch" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isThroughputPattern", "(", "MachineCombinerPattern", "Pattern", ")", "const", "{", "switch", "(", "Pattern", ")", "{", "default", ":", "break", ";", "case", "MachineCombinerPattern", "::", "FMULADDS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBS_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULADDD_OP2", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMULSUBD_OP2", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBS_OP1", ":", "case", "MachineCombinerPattern", "::", "FNMULSUBD_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP1", ":", "case", "MachineCombinerPattern", "::", "FMLAv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv1i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2i64_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f32_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv2f64_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4i32_indexed_OP2", ":", "case", "MachineCombinerPattern", "::", "FMLSv4f32_OP2", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "when", "a", "code", "sequence", "can", "improve", "throughput", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsGlobalInSmallSection", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ",", "SectionKind", "Kind", ")", "const", "{", "return", "(", "IsGlobalInSmallSectionImpl", "(", "GV", ",", "TM", ")", "&&", "(", "Kind", ".", "isData", "(", ")", "||", "Kind", ".", "isBSS", "(", ")", "||", "Kind", ".", "isCommon", "(", ")", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "const", "char", "*", "RISCVTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "OPCODE", "(", "RET_FLAG", ")", ";", "OPCODE", "(", "CALL", ")", ";", "OPCODE", "(", "PCREL_WRAPPER", ")", ";", "OPCODE", "(", "Hi", ")", ";", "OPCODE", "(", "Lo", ")", ";", "OPCODE", "(", "FENCE", ")", ";", "OPCODE", "(", "SELECT_CC", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "void", "insert", "(", "const", "GepNode", "*", "N", ")", "{", "insert", "(", "std", "::", "make_pair", "(", "N", ",", "++", "LastNum", ")", ")", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"If-convert TVM terminators\"", ";", "}", "</s>" ]

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

[ "TVM", "\"If-convert TVM terminators\"" ]

[]

[ "<s>", "static", "unsigned", "int", "nvptx_hard_regno_nregs", "(", "unsigned", "int", ",", "machine_mode", ")", "{", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "nvptx", "1" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 load / store optimization pass\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 load / store optimization pass\"" ]

[]

[ "<s>", "void", "ARMElfTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "bool", "isAAPCS_ABI", "=", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isAAPCS_ABI", "(", ")", ";", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "isAAPCS_ABI", ")", ";", "if", "(", "isAAPCS_ABI", "&&", "!", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isTargetNaCl", "(", ")", ")", "{", "LSDASection", "=", "NULL", ";", "}", "AttributesSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".ARM.attributes\"", ",", "ELF", "::", "SHT_ARM_ATTRIBUTES", ",", "0", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "\".ARM.attributes\"", "ARM", "0" ]

[]

[ "<s>", "bool", "s390_contiguous_bitmask_p", "(", "unsigned", "HOST_WIDE_INT", "in", ",", "int", "size", ",", "int", "*", "pos", ",", "int", "*", "length", ")", "{", "int", "tmp_pos", "=", "0", ";", "int", "tmp_length", "=", "0", ";", "int", "i", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "1ULL", ";", "bool", "contiguous", "=", "false", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size", ";", "mask", "<<=", "1", ",", "i", "++", ")", "{", "if", "(", "contiguous", ")", "{", "if", "(", "mask", "&", "in", ")", "tmp_length", "++", ";", "else", "break", ";", "}", "else", "{", "if", "(", "mask", "&", "in", ")", "{", "contiguous", "=", "true", ";", "tmp_length", "++", ";", "}", "else", "tmp_pos", "++", ";", "}", "}", "if", "(", "!", "tmp_length", ")", "return", "false", ";", "mask", "=", "(", "-", "1LL", "&", "~", "(", "(", "(", "1ULL", "<<", "(", "tmp_length", "+", "tmp_pos", "-", "1", ")", ")", "<<", "1", ")", "-", "1", ")", ")", ";", "if", "(", "(", "unsigned", ")", "size", "<", "sizeof", "(", "HOST_WIDE_INT", ")", "*", "BITS_PER_UNIT", ")", "mask", "&=", "(", "HOST_WIDE_INT_1U", "<<", "size", ")", "-", "1", ";", "if", "(", "mask", "&", "in", ")", "return", "false", ";", "if", "(", "tmp_length", "+", "tmp_pos", "-", "1", ">", "size", ")", "return", "false", ";", "if", "(", "length", ")", "*", "length", "=", "tmp_length", ";", "if", "(", "pos", ")", "*", "pos", "=", "tmp_pos", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "IN", "contains", "a", "contiguous", "bitfield", "in", "the", "lower", "SIZE", "bits", "and", "no", "other", "bits", "are", "set", "in", "IN", ".", "POS", "and", "LENGTH", "can", "be", "used", "to", "obtain", "the", "start", "position", "and", "the", "length", "of", "the", "bitfield", ".", "POS", "gives", "the", "position", "of", "the", "first", "bit", "of", "the", "bitfield", "counting", "from", "the", "lowest", "order", "bit", "starting", "with", "zero", ".", "In", "order", "to", "use", "this", "value", "for", "S/390", "instructions", "this", "has", "to", "be", "converted", "to", "``", "bits", "big", "endian", "''", "style", "." ]

[ "s390", "0", "0", "1ULL", "0", "1", "1LL", "1ULL", "1", "1", "1", "1", "1" ]

[]

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

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

[ "Blackfin", "ISD::OutputArg", "16", "0", "0", "\"Can only return in registers!\"", "\"Unknown loc info!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "1", "BFISD::RET_FLAG", "MVT::Other", "BFISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "riscv_pass_by_reference", "(", "cumulative_args_t", "cum_v", ",", "enum", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "HOST_WIDE_INT", "size", "=", "type", "?", "int_size_in_bytes", "(", "type", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", ";", "struct", "riscv_arg_info", "info", ";", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "cum", "!=", "NULL", ")", "{", "riscv_get_arg_info", "(", "&", "info", ",", "cum", ",", "mode", ",", "type", ",", "named", ",", "false", ")", ";", "if", "(", "info", ".", "num_fprs", ")", "return", "false", ";", "}", "return", "!", "IN_RANGE", "(", "size", ",", "0", ",", "2", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "riscv", "0", "2" ]

[]

[ "<s>", "bool", "PULPHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* PULP Hardware Loops *********\\n\"", ")", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "hasPULPExtV2", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "{", "return", "false", ";", "}", "bool", "Changed", "=", "false", ";", "NumHWLoopsInternal", "=", "0", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "RISCVSubtarget", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "TII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "L", ":", "*", "MLI", ")", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "{", "bool", "L0Used", "=", "false", ";", "bool", "L1Used", "=", "false", ";", "KnownHardwareLoops", ".", "clear", "(", ")", ";", "Changed", "|=", "convertToHardwareLoop", "(", "L", ",", "L0Used", ",", "L1Used", ")", ";", "}", "if", "(", "Changed", ")", "{", "errs", "(", ")", ".", "changeColor", "(", "raw_fd_ostream", "::", "Colors", "::", "BLUE", ",", "true", ")", ";", "errs", "(", ")", "<<", "\"Created \"", "<<", "NumHWLoopsInternal", "<<", "\" hardware loops in \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"!\\n\"", ";", "errs", "(", ")", ".", "resetColor", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "RI5CY", "\"********* PULP Hardware Loops *********\\n\"", "RISCV", "0", "RISCV", "RISCV", "\"Created \"", "\" hardware loops in \"", "\"!\\n\"" ]

[]

[ "<s>", "const", "char", "*", "riscv_output_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "enum", "rtx_code", "dest_code", ",", "src_code", ";", "machine_mode", "mode", ";", "bool", "dbl_p", ";", "dest_code", "=", "GET_CODE", "(", "dest", ")", ";", "src_code", "=", "GET_CODE", "(", "src", ")", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "dbl_p", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ";", "if", "(", "dbl_p", "&&", "riscv_split_64bit_move_p", "(", "dest", ",", "src", ")", ")", "return", "\"#\"", ";", "if", "(", "dest_code", "==", "REG", "&&", "GP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "src_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "return", "dbl_p", "?", "\"fmv.x.d\\t%0,%1\"", ":", "\"fmv.x.w\\t%0,%1\"", ";", "if", "(", "src_code", "==", "MEM", ")", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "\"lbu\\t%0,%1\"", ";", "case", "2", ":", "return", "\"lhu\\t%0,%1\"", ";", "case", "4", ":", "return", "\"lw\\t%0,%1\"", ";", "case", "8", ":", "return", "\"ld\\t%0,%1\"", ";", "}", "if", "(", "src_code", "==", "CONST_INT", ")", "{", "if", "(", "SMALL_OPERAND", "(", "INTVAL", "(", "src", ")", ")", "||", "LUI_OPERAND", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"li\\t%0,%1\"", ";", "if", "(", "TARGET_ZBS", "&&", "SINGLE_BIT_MASK_OPERAND", "(", "INTVAL", "(", "src", ")", ")", ")", "return", "\"bseti\\t%0,zero,%S1\"", ";", "abort", "(", ")", ";", "}", "if", "(", "src_code", "==", "HIGH", ")", "return", "\"lui\\t%0,%h1\"", ";", "if", "(", "symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "switch", "(", "riscv_classify_symbolic_expression", "(", "src", ")", ")", "{", "case", "SYMBOL_GOT_DISP", ":", "return", "\"la\\t%0,%1\"", ";", "case", "SYMBOL_ABSOLUTE", ":", "return", "\"lla\\t%0,%1\"", ";", "case", "SYMBOL_PCREL", ":", "return", "\"lla\\t%0,%1\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "(", "src_code", "==", "REG", "&&", "GP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "||", "(", "src", "==", "CONST0_RTX", "(", "mode", ")", ")", ")", "{", "if", "(", "dest_code", "==", "REG", ")", "{", "if", "(", "GP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "return", "\"mv\\t%0,%z1\"", ";", "if", "(", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "!", "dbl_p", ")", "return", "\"fmv.w.x\\t%0,%z1\"", ";", "if", "(", "TARGET_64BIT", ")", "return", "\"fmv.d.x\\t%0,%z1\"", ";", "gcc_assert", "(", "src", "==", "CONST0_RTX", "(", "mode", ")", ")", ";", "return", "\"fcvt.d.w\\t%0,x0\"", ";", "}", "}", "if", "(", "dest_code", "==", "MEM", ")", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "\"sb\\t%z1,%0\"", ";", "case", "2", ":", "return", "\"sh\\t%z1,%0\"", ";", "case", "4", ":", "return", "\"sw\\t%z1,%0\"", ";", "case", "8", ":", "return", "\"sd\\t%z1,%0\"", ";", "}", "}", "if", "(", "src_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "src", ")", ")", ")", "{", "if", "(", "dest_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "return", "dbl_p", "?", "\"fmv.d\\t%0,%1\"", ":", "\"fmv.s\\t%0,%1\"", ";", "if", "(", "dest_code", "==", "MEM", ")", "return", "dbl_p", "?", "\"fsd\\t%1,%0\"", ":", "\"fsw\\t%1,%0\"", ";", "}", "if", "(", "dest_code", "==", "REG", "&&", "FP_REG_P", "(", "REGNO", "(", "dest", ")", ")", ")", "{", "if", "(", "src_code", "==", "MEM", ")", "return", "dbl_p", "?", "\"fld\\t%0,%1\"", ":", "\"flw\\t%0,%1\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "instructions", "to", "move", "SRC", "into", "DEST", ".", "Assume", "that", "SRC", "is", "operand", "1", "and", "DEST", "is", "operand", "0", "." ]

[ "riscv", "8", "\"#\"", "\"fmv.x.d\\t%0,%1\"", "\"fmv.x.w\\t%0,%1\"", "1", "\"lbu\\t%0,%1\"", "2", "\"lhu\\t%0,%1\"", "4", "\"lw\\t%0,%1\"", "8", "\"ld\\t%0,%1\"", "\"li\\t%0,%1\"", "\"bseti\\t%0,zero,%S1\"", "\"lui\\t%0,%h1\"", "\"la\\t%0,%1\"", "\"lla\\t%0,%1\"", "\"lla\\t%0,%1\"", "\"mv\\t%0,%z1\"", "\"fmv.w.x\\t%0,%z1\"", "\"fmv.d.x\\t%0,%z1\"", "\"fcvt.d.w\\t%0,x0\"", "1", "\"sb\\t%z1,%0\"", "2", "\"sh\\t%z1,%0\"", "4", "\"sw\\t%z1,%0\"", "8", "\"sd\\t%z1,%0\"", "\"fmv.d\\t%0,%1\"", "\"fmv.s\\t%0,%1\"", "\"fsd\\t%1,%0\"", "\"fsw\\t%1,%0\"", "\"fld\\t%0,%1\"", "\"flw\\t%0,%1\"" ]

[]

[ "<s>", "static", "void", "riscv_save_reg", "(", "rtx", "reg", ",", "rtx", "mem", ")", "{", "riscv_emit_move", "(", "mem", ",", "reg", ")", ";", "riscv_set_frame_expr", "(", "riscv_frame_set", "(", "mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Save", "register", "REG", "to", "MEM", ".", "Make", "the", "instruction", "frame-related", "." ]

[ "riscv" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"PowerPC Branch Selector\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"PowerPC Branch Selector\"" ]

[]

[ "<s>", "void", "ARCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Determine Callee Saves: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "SavedRegs", ".", "set", "(", "ARC", "::", "BLINK", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Determine Callee Saves: \"", "\"\\n\"", "ARC::BLINK" ]

[]

[ "<s>", "static", "int", "address_needs_split", "(", "rtx", "mem", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem", ")", ")", "<", "16", "&&", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem", ")", ")", "<", "4", "||", "!", "(", "store_with_one_insn_p", "(", "mem", ")", "||", "mem_is_padded_component_ref", "(", "mem", ")", ")", ")", ")", "return", "1", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "when", "the", "address", "is", "not", "valid", "for", "a", "simple", "load", "and", "store", "as", "required", "by", "the", "'_mov", "*", "'", "patterns", ".", "We", "could", "make", "this", "less", "strict", "for", "loads", ",", "but", "we", "prefer", "mem", "'s", "to", "look", "the", "same", "so", "they", "are", "more", "likely", "to", "be", "merged", "." ]

[ "spu", "16", "4", "1", "0" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "shouldClusterMemOps", "(", "MachineInstr", "*", "FirstLdSt", ",", "MachineInstr", "*", "SecondLdSt", ",", "unsigned", "NumLoads", ")", "const", "{", "const", "MachineOperand", "*", "FirstDst", "=", "nullptr", ";", "const", "MachineOperand", "*", "SecondDst", "=", "nullptr", ";", "if", "(", "isDS", "(", "*", "FirstLdSt", ")", "&&", "isDS", "(", "*", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "*", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "*", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdst", ")", ";", "}", "if", "(", "isSMRD", "(", "*", "FirstLdSt", ")", "&&", "isSMRD", "(", "*", "SecondLdSt", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "*", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "*", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "sdst", ")", ";", "}", "if", "(", "(", "isMUBUF", "(", "*", "FirstLdSt", ")", "&&", "isMUBUF", "(", "*", "SecondLdSt", ")", ")", "||", "(", "isMTBUF", "(", "*", "FirstLdSt", ")", "&&", "isMTBUF", "(", "*", "SecondLdSt", ")", ")", ")", "{", "FirstDst", "=", "getNamedOperand", "(", "*", "FirstLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "SecondDst", "=", "getNamedOperand", "(", "*", "SecondLdSt", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "}", "if", "(", "!", "FirstDst", "||", "!", "SecondDst", ")", "return", "false", ";", "unsigned", "LoadClusterThreshold", "=", "16", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "FirstLdSt", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "MRI", ".", "getRegClass", "(", "FirstDst", "->", "getReg", "(", ")", ")", ";", "return", "(", "NumLoads", "*", "DstRC", "->", "getSize", "(", ")", ")", "<=", "LoadClusterThreshold", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AMDGPU", "SI", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "AMDGPU::OpName", "16" ]

[]

[ "<s>", "void", "gen_conditional_branch", "(", "rtx", "operands", "[", "]", ",", "enum", "rtx_code", "test_code", ")", "{", "enum", "cmp_type", "type", "=", "branch_type", ";", "rtx", "cmp0", "=", "branch_cmp", "[", "0", "]", ";", "rtx", "cmp1", "=", "branch_cmp", "[", "1", "]", ";", "enum", "machine_mode", "mode", ";", "rtx", "reg", ";", "int", "invert", ";", "rtx", "label1", ",", "label2", ";", "switch", "(", "type", ")", "{", "case", "CMP_SI", ":", "case", "CMP_DI", ":", "mode", "=", "type", "==", "CMP_SI", "?", "SImode", ":", "DImode", ";", "invert", "=", "0", ";", "reg", "=", "gen_int_relational", "(", "test_code", ",", "NULL_RTX", ",", "cmp0", ",", "cmp1", ",", "&", "invert", ")", ";", "if", "(", "reg", ")", "{", "cmp0", "=", "reg", ";", "cmp1", "=", "const0_rtx", ";", "test_code", "=", "NE", ";", "}", "else", "if", "(", "GET_CODE", "(", "cmp1", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "cmp1", ")", "!=", "0", ")", "cmp1", "=", "force_reg", "(", "mode", ",", "cmp1", ")", ";", "break", ";", "case", "CMP_SF", ":", "case", "CMP_DF", ":", "reg", "=", "gen_reg_rtx", "(", "CCmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "gen_rtx_fmt_ee", "(", "test_code", "==", "NE", "?", "EQ", ":", "test_code", ",", "CCmode", ",", "cmp0", ",", "cmp1", ")", ")", ")", ";", "test_code", "=", "test_code", "==", "NE", "?", "EQ", ":", "NE", ";", "mode", "=", "CCmode", ";", "cmp0", "=", "reg", ";", "cmp1", "=", "const0_rtx", ";", "invert", "=", "0", ";", "break", ";", "default", ":", "abort_with_insn", "(", "gen_rtx_fmt_ee", "(", "test_code", ",", "VOIDmode", ",", "cmp0", ",", "cmp1", ")", ",", "\"bad test\"", ")", ";", "}", "label1", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "0", "]", ")", ";", "label2", "=", "pc_rtx", ";", "if", "(", "invert", ")", "{", "label2", "=", "label1", ";", "label1", "=", "pc_rtx", ";", "}", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_fmt_ee", "(", "test_code", ",", "mode", ",", "cmp0", ",", "cmp1", ")", ",", "label1", ",", "label2", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "common", "code", "for", "doing", "conditional", "branches", ".", "operand", "[", "0", "]", "is", "the", "label", "to", "jump", "to", ".", "The", "comparison", "operands", "are", "saved", "away", "by", "cmp", "{", "si", ",", "di", ",", "sf", ",", "df", "}", "." ]

[ "iq2000", "0", "1", "0", "0", "0", "\"bad test\"", "0" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ")", "const", "{", "if", "(", "getEffectiveCallingConv", "(", "CallConv", ",", "isVarArg", ")", "!=", "CallingConv", "::", "ARM_AAPCS_VFP", ")", "return", "false", ";", "HABaseType", "Base", "=", "HA_UNKNOWN", ";", "uint64_t", "Members", "=", "0", ";", "bool", "result", "=", "isHomogeneousAggregate", "(", "Ty", ",", "Base", ",", "Members", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"isHA: \"", "<<", "result", "<<", "\" \"", ";", "Ty", "->", "dump", "(", ")", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

[ "ARM", "ARM", "ARM", "0", "\"isHA: \"", "\" \"" ]

[]

[ "<s>", "static", "rtx", "ix86_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "machine_mode", "mode", "=", "arg", ".", "mode", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "rtx", "reg", ";", "if", "(", "!", "cum", "->", "caller", "&&", "cfun", "->", "machine", "->", "func_type", "!=", "TYPE_NORMAL", ")", "{", "gcc_assert", "(", "arg", ".", "type", "!=", "NULL_TREE", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "arg", ".", "type", ")", ")", "{", "gcc_assert", "(", "TYPE_MODE", "(", "arg", ".", "type", ")", "==", "ptr_mode", ")", ";", "reg", "=", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ";", "}", "else", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_EXCEPTION", "&&", "TREE_CODE", "(", "arg", ".", "type", ")", "==", "INTEGER_TYPE", "&&", "TYPE_MODE", "(", "arg", ".", "type", ")", "==", "word_mode", ")", ";", "reg", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "}", "return", "reg", ";", "}", "bytes", "=", "arg", ".", "promoted_size_in_bytes", "(", ")", ";", "words", "=", "CEIL", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "arg", ".", "type", "&&", "TREE_CODE", "(", "arg", ".", "type", ")", "==", "VECTOR_TYPE", ")", "mode", "=", "type_natural_mode", "(", "arg", ".", "type", ",", "cum", ",", "false", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "reg", "=", "function_arg_ms_64", "(", "cum", ",", "mode", ",", "arg", ".", "mode", ",", "arg", ".", "named", ",", "arg", ".", "type", ",", "bytes", ")", ";", "else", "reg", "=", "function_arg_64", "(", "cum", ",", "mode", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ")", ";", "}", "else", "reg", "=", "function_arg_32", "(", "cum", ",", "mode", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "bytes", ",", "words", ")", ";", "if", "(", "reg", "==", "NULL_RTX", "&&", "cum", "->", "caller", ")", "cfun", "->", "machine", "->", "outgoing_args_on_stack", "=", "true", ";", "return", "reg", ";", "}", "</s>" ]

[ "Return", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Return", "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", ".", "It", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "gives", "information", "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", ")", "." ]

[ "i386", "2" ]

[]

[ "<s>", "static", "bool", "arm_const_not_ok_for_debug_p", "(", "rtx", "p", ")", "{", "tree", "decl_op0", "=", "NULL", ";", "tree", "decl_op1", "=", "NULL", ";", "if", "(", "GET_CODE", "(", "p", ")", "==", "MINUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "p", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "{", "decl_op1", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "p", ",", "1", ")", ")", ";", "if", "(", "decl_op1", "&&", "GET_CODE", "(", "XEXP", "(", "p", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "(", "decl_op0", "=", "SYMBOL_REF_DECL", "(", "XEXP", "(", "p", ",", "0", ")", ")", ")", ")", "{", "if", "(", "(", "TREE_CODE", "(", "decl_op1", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "decl_op1", ")", "==", "CONST_DECL", ")", "&&", "(", "TREE_CODE", "(", "decl_op0", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "decl_op0", ")", "==", "CONST_DECL", ")", ")", "return", "(", "get_variable_section", "(", "decl_op1", ",", "false", ")", "!=", "get_variable_section", "(", "decl_op0", ",", "false", ")", ")", ";", "if", "(", "TREE_CODE", "(", "decl_op1", ")", "==", "LABEL_DECL", "&&", "TREE_CODE", "(", "decl_op0", ")", "==", "LABEL_DECL", ")", "return", "(", "DECL_CONTEXT", "(", "decl_op1", ")", "!=", "DECL_CONTEXT", "(", "decl_op0", ")", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "is", "a", "temporary", "fix", "for", "PR60655", ".", "Ideally", "we", "need", "to", "handle", "most", "of", "these", "cases", "in", "the", "generic", "part", "but", "currently", "we", "reject", "minus", "(", "..", ")", "(", "sym_ref", ")", ".", "We", "try", "to", "ameliorate", "the", "case", "with", "minus", "(", "sym_ref1", ")", "(", "sym_ref2", ")", "where", "they", "are", "in", "the", "same", "section", "." ]

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

[]

[ "<s>", "static", "bool", "insn_ok_now", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "int", "i", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "if", "(", "recog", "(", "pattern", ",", "insn", ",", "0", ")", ">", "-", "1", ")", "{", "extract_insn", "(", "insn", ")", ";", "if", "(", "constrain_operands", "(", "1", ",", "get_preferred_alternatives", "(", "insn", ")", ")", ")", "{", "fprintf", "(", "stderr", ",", "\"\\033[32m\"", ")", ";", "debug_rtx", "(", "insn", ")", ";", "fprintf", "(", "stderr", ",", "\"\\033[0m\"", ")", ";", "if", "(", "SET_P", "(", "pattern", ")", ")", "record_content", "(", "SET_DEST", "(", "pattern", ")", ",", "SET_SRC", "(", "pattern", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "if", "(", "GET_CODE", "(", "OP", "(", "i", ")", ")", "==", "MEM", "&&", "GET_MODE", "(", "XEXP", "(", "OP", "(", "i", ")", ",", "0", ")", ")", "==", "SImode", "&&", "GET_CODE", "(", "XEXP", "(", "OP", "(", "i", ")", ",", "0", ")", ")", "!=", "UNSPEC", ")", "return", "false", ";", "return", "true", ";", "}", "}", "else", "{", "cfun", "->", "machine", "->", "virt_insns_ok", "=", "1", ";", "if", "(", "recog", "(", "pattern", ",", "insn", ",", "0", ")", ">", "-", "1", ")", "{", "extract_insn", "(", "insn", ")", ";", "if", "(", "constrain_operands", "(", "0", ",", "get_preferred_alternatives", "(", "insn", ")", ")", ")", "{", "cfun", "->", "machine", "->", "virt_insns_ok", "=", "0", ";", "return", "false", ";", "}", "}", "fprintf", "(", "stderr", ",", "\"\\033[41;30m Unrecognized *virtual* insn \\033[0m\\n\"", ")", ";", "debug_rtx", "(", "insn", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "stderr", ",", "\"\\033[31m\"", ")", ";", "debug_rtx", "(", "insn", ")", ";", "fprintf", "(", "stderr", ",", "\"\\033[0m\"", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Rescans", "an", "insn", "to", "see", "if", "it", "'s", "recognized", "again", ".", "This", "is", "done", "carefully", "to", "ensure", "that", "all", "the", "constraint", "information", "is", "accurate", "for", "the", "newly", "matched", "insn", "." ]

[ "rl78", "1", "0", "1", "1", "\"\\033[32m\"", "\"\\033[0m\"", "0", "0", "0", "1", "0", "1", "0", "0", "\"\\033[41;30m Unrecognized *virtual* insn \\033[0m\\n\"", "\"\\033[31m\"", "\"\\033[0m\"" ]

[]

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

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

[ "LEG", "LEG" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "!", "StackSize", ")", "return", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "Move32R16", ")", ",", "Mips", "::", "SP", ")", ".", "addReg", "(", "Mips", "::", "S0", ")", ";", "TII", ".", "restoreFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips::Move32R16", "Mips::SP", "Mips::S0", "Mips::SP" ]

[]

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

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

[ "SystemZ" ]

[]

[ "<s>", "bool", "m68k_legitimate_index_reg_p", "(", "rtx", "x", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "(", "strict_p", "?", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "x", ")", ")", ":", "REGNO_OK_FOR_INDEX_NONSTRICT_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "index", "register", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "." ]

[ "m68k" ]

[]

[ "<s>", "static", "reg_class_t", "loongarch_secondary_reload", "(", "bool", "in_p", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "reg_class_t", "rclass", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", "ATTRIBUTE_UNUSED", ")", "{", "int", "regno", ";", "regno", "=", "true_regnum", "(", "x", ")", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "FP_REGS", ")", ")", "{", "if", "(", "regno", "<", "0", "||", "(", "MEM_P", "(", "x", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "4", "||", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ")", ")", "return", "NO_REGS", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "||", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "NO_REGS", ";", "if", "(", "CONSTANT_P", "(", "x", ")", "&&", "!", "targetm", ".", "cannot_force_const_mem", "(", "mode", ",", "x", ")", ")", "return", "NO_REGS", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "loongarch_mode_ok_for_mov_fmt_p", "(", "mode", ")", ")", "return", "NO_REGS", ";", "return", "GR_REGS", ";", "}", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "return", "reg_class_subset_p", "(", "rclass", ",", "GR_REGS", ")", "?", "NO_REGS", ":", "GR_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "required", "for", "a", "secondary", "register", "when", "copying", "between", "one", "of", "the", "registers", "in", "RCLASS", "and", "value", "X", ",", "which", "has", "mode", "MODE", ".", "X", "is", "the", "source", "of", "the", "move", "if", "IN_P", ",", "otherwise", "it", "is", "the", "destination", ".", "Return", "NO_REGS", "if", "no", "secondary", "register", "is", "needed", "." ]

[ "loongarch", "0", "4", "8" ]

[]

[ "<s>", "static", "void", "do_load_for_compare", "(", "rtx", "reg", ",", "rtx", "mem", ",", "machine_mode", "mode", ")", "{", "switch", "(", "GET_MODE", "(", "reg", ")", ")", "{", "case", "E_DImode", ":", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "emit_insn", "(", "gen_zero_extendqidi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhidi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "E_SImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_insn", "(", "gen_bswapsi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendsidi2", "(", "reg", ",", "src", ")", ")", ";", "}", "break", ";", "case", "E_DImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapdi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movdi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "E_SImode", ":", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "emit_insn", "(", "gen_zero_extendqisi2", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_HImode", ":", "{", "rtx", "src", "=", "mem", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "{", "src", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_insn", "(", "gen_bswaphi2", "(", "src", ",", "mem", ")", ")", ";", "}", "emit_insn", "(", "gen_zero_extendhisi2", "(", "reg", ",", "src", ")", ")", ";", "break", ";", "}", "case", "E_SImode", ":", "if", "(", "!", "BYTES_BIG_ENDIAN", ")", "emit_insn", "(", "gen_bswapsi2", "(", "reg", ",", "mem", ")", ")", ";", "else", "emit_insn", "(", "gen_movsi", "(", "reg", ",", "mem", ")", ")", ";", "break", ";", "case", "E_DImode", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Figure", "out", "the", "correct", "instructions", "to", "generate", "to", "load", "data", "for", "block", "compare", ".", "MODE", "is", "used", "for", "the", "read", "from", "memory", ",", "and", "data", "is", "zero", "extended", "if", "REG", "is", "wider", "than", "MODE", ".", "If", "LE", "code", "is", "being", "generated", ",", "bswap", "loads", "are", "used", ".", "REG", "is", "the", "destination", "register", "to", "move", "the", "data", "into", ".", "MEM", "is", "the", "memory", "block", "being", "read", ".", "MODE", "is", "the", "mode", "of", "memory", "to", "use", "for", "the", "read", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "AMDGPULegalizerInfo", "::", "legalizeCustom", "(", "MachineInstr", "&", "MI", ",", "MachineRegisterInfo", "&", "MRI", ",", "MachineIRBuilder", "&", "B", ",", "GISelChangeObserver", "&", "Observer", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "G_ADDRSPACE_CAST", ":", "return", "legalizeAddrSpaceCast", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FRINT", ":", "return", "legalizeFrint", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FCEIL", ":", "return", "legalizeFceil", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INTRINSIC_TRUNC", ":", "return", "legalizeIntrinsicTrunc", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_SITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "true", ")", ";", "case", "TargetOpcode", "::", "G_UITOFP", ":", "return", "legalizeITOFP", "(", "MI", ",", "MRI", ",", "B", ",", "false", ")", ";", "case", "TargetOpcode", "::", "G_FMINNUM", ":", "case", "TargetOpcode", "::", "G_FMAXNUM", ":", "case", "TargetOpcode", "::", "G_FMINNUM_IEEE", ":", "case", "TargetOpcode", "::", "G_FMAXNUM_IEEE", ":", "return", "legalizeMinNumMaxNum", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_EXTRACT_VECTOR_ELT", ":", "return", "legalizeExtractVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_INSERT_VECTOR_ELT", ":", "return", "legalizeInsertVectorElt", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_FSIN", ":", "case", "TargetOpcode", "::", "G_FCOS", ":", "return", "legalizeSinCos", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_GLOBAL_VALUE", ":", "return", "legalizeGlobalValue", "(", "MI", ",", "MRI", ",", "B", ")", ";", "case", "TargetOpcode", "::", "G_LOAD", ":", "return", "legalizeLoad", "(", "MI", ",", "MRI", ",", "B", ",", "Observer", ")", ";", "case", "TargetOpcode", "::", "G_FMAD", ":", "return", "legalizeFMad", "(", "MI", ",", "MRI", ",", "B", ")", ";", "default", ":", "return", "false", ";", "}", "llvm_unreachable", "(", "\"expected switch to return\"", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "get_dest_uid", "(", "rtx_insn", "*", "label", ",", "int", "max_uid", ")", "{", "rtx_insn", "*", "dest", "=", "next_real_insn", "(", "label", ")", ";", "if", "(", "!", "dest", ")", "return", "0", ";", "int", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "while", "(", "dest_uid", ">=", "max_uid", ")", "{", "dest", "=", "NEXT_INSN", "(", "dest", ")", ";", "dest_uid", "=", "INSN_UID", "(", "dest", ")", ";", "}", "if", "(", "JUMP_P", "(", "dest", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "dest", ")", ")", "==", "RETURN", ")", "return", "0", ";", "return", "dest_uid", ";", "}", "</s>" ]

[ "Return", "the", "UID", "of", "the", "insn", "that", "follows", "the", "specified", "label", "." ]

[ "sh", "0", "0" ]

[]

[ "<s>", "static", "void", "mips_extra_live_on_entry", "(", "bitmap", "regs", ")", "{", "if", "(", "TARGET_USE_GOT", ")", "{", "if", "(", "!", "TARGET_ABSOLUTE_ABICALLS", ")", "bitmap_set_bit", "(", "regs", ",", "PIC_FUNCTION_ADDR_REGNUM", ")", ";", "if", "(", "TARGET_MIPS16", ")", "bitmap_set_bit", "(", "regs", ",", "MIPS16_PIC_TEMP_REGNUM", ")", ";", "bitmap_set_bit", "(", "regs", ",", "GOT_VERSION_REGNUM", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_EXTRA_LIVE_ON_ENTRY", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", "MRI", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "if", "(", "!", "WebAssembly", "::", "isArgument", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "break", ";", "int64_t", "Imm", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg VReg \"", "<<", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "<<", "\" -> WAReg \"", "<<", "Imm", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "Imm", ")", ";", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "0", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "Register", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly::isArgument", "1", "\"Arg VReg \"", "0", "\" -> WAReg \"", "\"\\n\"", "0", "0", "0", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"", "WebAssembly", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"" ]

[]

[ "<s>", "virtual", "llvm", "::", "StringRef", "getPassName", "(", ")", "const", "{", "return", "\"localaccessortosharedmemory\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"localaccessortosharedmemory\"" ]

[]

[ "<s>", "virtual", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_Token", ":", "OS", "<<", "\"Token: \"", "<<", "getToken", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"Reg: #\"", "<<", "getReg", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "k_Immediate", ":", "OS", "<<", "\"Imm: \"", "<<", "getImm", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "k_MemoryReg", ":", "OS", "<<", "\"Mem: \"", "<<", "getMemBase", "(", ")", "<<", "\"+\"", "<<", "getMemOffsetReg", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "case", "k_MemoryImm", ":", "assert", "(", "getMemOff", "(", ")", "!=", "0", ")", ";", "OS", "<<", "\"Mem: \"", "<<", "getMemBase", "(", ")", "<<", "\"+\"", "<<", "*", "getMemOff", "(", ")", "<<", "\"\\n\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Sparc", "\"Token: \"", "\"\\n\"", "\"Reg: #\"", "\"\\n\"", "\"Imm: \"", "\"\\n\"", "\"Mem: \"", "\"+\"", "\"\\n\"", "0", "\"Mem: \"", "\"+\"", "\"\\n\"" ]

[]

[ "<s>", "int", "c4x_T_constraint", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "LO_SUM", ")", "{", "return", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", "&&", "GET_MODE", "(", "op", ")", "==", "Pmode", "&&", "SYMBOL_REF_FUNCTION_P", "(", "op", ")", ";", "}", "if", "(", "GET_MODE", "(", "op", ")", "==", "HImode", "||", "GET_CODE", "(", "op", ")", "==", "HFmode", ")", "return", "0", ";", "if", "(", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "REG", ")", "&&", "(", "REGNO", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "DP_REGNO", ")", ")", "return", "c4x_U_constraint", "(", "XEXP", "(", "op", ",", "1", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Direct", "memory", "operand", "." ]

[ "c4x", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "mep_mul_hilo_bypass_p", "(", "rtx_insn", "*", "prev", ",", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "SET_SRC", "(", "pat", ")", ",", "NONCONST", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "REGNO", "(", "x", ")", "!=", "LO_REGNO", "&&", "REGNO", "(", "x", ")", "!=", "HI_REGNO", "&&", "reg_set_p", "(", "x", ",", "prev", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", ",", "apart", "from", "HI/LO", ",", "there", "are", "no", "true", "dependencies", "between", "multiplication", "instructions", "PREV", "and", "INSN", "." ]

[ "mep", "0", "0" ]

[]

[ "<s>", "static", "void", "mips_start_unique_function", "(", "const", "char", "*", "name", ")", "{", "tree", "decl", ";", "decl", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "FUNCTION_DECL", ",", "get_identifier", "(", "name", ")", ",", "build_function_type_list", "(", "void_type_node", ",", "NULL_TREE", ")", ")", ";", "DECL_RESULT", "(", "decl", ")", "=", "build_decl", "(", "BUILTINS_LOCATION", ",", "RESULT_DECL", ",", "NULL_TREE", ",", "void_type_node", ")", ";", "TREE_PUBLIC", "(", "decl", ")", "=", "1", ";", "TREE_STATIC", "(", "decl", ")", "=", "1", ";", "cgraph_node", "::", "create", "(", "decl", ")", "->", "set_comdat_group", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "targetm", ".", "asm_out", ".", "unique_section", "(", "decl", ",", "0", ")", ";", "switch_to_section", "(", "get_named_section", "(", "decl", ",", "NULL", ",", "0", ")", ")", ";", "targetm", ".", "asm_out", ".", "globalize_label", "(", "asm_out_file", ",", "name", ")", ";", "fputs", "(", "\"\\t.hidden\\t\"", ",", "asm_out_file", ")", ";", "assemble_name", "(", "asm_out_file", ",", "name", ")", ";", "putc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Declare", "a", "unique", ",", "locally-binding", "function", "called", "NAME", ",", "then", "start", "its", "definition", "." ]

[ "mips", "1", "1", "0", "0", "\"\\t.hidden\\t\"" ]

[]

[ "<s>", "void", "BPFFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "BPF", "BPF" ]

[]

[ "<s>", "void", "constant_to_array", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "char", "arr", "[", "16", "]", ")", "{", "HOST_WIDE_INT", "val", ";", "int", "i", ",", "j", ",", "first", ";", "memset", "(", "arr", ",", "0", ",", "16", ")", ";", "mode", "=", "GET_MODE", "(", "x", ")", "!=", "VOIDmode", "?", "GET_MODE", "(", "x", ")", ":", "mode", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", "||", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "(", "mode", "==", "SFmode", "||", "mode", "==", "DFmode", ")", ")", ")", "{", "gcc_assert", "(", "mode", "!=", "VOIDmode", "&&", "mode", "!=", "BLKmode", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "val", "=", "const_double_to_hwint", "(", "x", ")", ";", "else", "val", "=", "INTVAL", "(", "x", ")", ";", "first", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "for", "(", "i", "=", "first", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "arr", "[", "i", "]", "=", "val", "&", "0xff", ";", "val", ">>=", "8", ";", "}", "for", "(", "j", "=", "0", ",", "i", "=", "first", "+", "1", ";", "i", "<", "16", ";", "i", "++", ")", "{", "arr", "[", "i", "]", "=", "arr", "[", "j", "]", ";", "j", "=", "(", "j", "==", "first", ")", "?", "0", ":", "j", "+", "1", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "val", "=", "CONST_DOUBLE_LOW", "(", "x", ")", ";", "for", "(", "i", "=", "15", ";", "i", ">=", "8", ";", "i", "--", ")", "{", "arr", "[", "i", "]", "=", "val", "&", "0xff", ";", "val", ">>=", "8", ";", "}", "val", "=", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "for", "(", "i", "=", "7", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "arr", "[", "i", "]", "=", "val", "&", "0xff", ";", "val", ">>=", "8", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_VECTOR", ")", "{", "int", "units", ";", "rtx", "elt", ";", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "units", "=", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "units", ";", "i", "++", ")", "{", "elt", "=", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "elt", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "elt", ")", "==", "CONST_DOUBLE", ")", "{", "if", "(", "GET_CODE", "(", "elt", ")", "==", "CONST_DOUBLE", ")", "val", "=", "const_double_to_hwint", "(", "elt", ")", ";", "else", "val", "=", "INTVAL", "(", "elt", ")", ";", "first", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ";", "if", "(", "first", "+", "i", "*", "GET_MODE_SIZE", "(", "mode", ")", ">", "16", ")", "abort", "(", ")", ";", "for", "(", "j", "=", "first", ";", "j", ">=", "0", ";", "j", "--", ")", "{", "arr", "[", "j", "+", "i", "*", "GET_MODE_SIZE", "(", "mode", ")", "]", "=", "val", "&", "0xff", ";", "val", ">>=", "8", ";", "}", "}", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Convert", "a", "CONST_INT", ",", "CONST_DOUBLE", ",", "or", "CONST_VECTOR", "into", "a", "16", "byte", "array", ".", "Use", "MODE", "for", "CONST_INT", "'s", ".", "When", "the", "constant", "'s", "mode", "is", "smaller", "than", "16", "bytes", ",", "the", "value", "is", "repeated", "across", "the", "rest", "of", "the", "array", "." ]

[ "spu", "16", "0", "16", "1", "0", "0xff", "8", "0", "1", "16", "0", "1", "15", "8", "0xff", "8", "7", "0", "0xff", "8", "0", "1", "16", "0", "0xff", "8" ]

[]

[ "<s>", "static", "void", "rs6000_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "switch", "(", "size", ")", "{", "case", "4", ":", "fputs", "(", "\"\\t.long\\t\"", ",", "file", ")", ";", "break", ";", "case", "8", ":", "fputs", "(", "DOUBLE_INT_ASM_OP", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@dtprel+0x8000\"", ",", "file", ")", ";", "else", "if", "(", "TARGET_XCOFF", "&&", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", "{", "switch", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "{", "case", "0", ":", "break", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "fputs", "(", "\"@le\"", ",", "file", ")", ";", "break", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "fputs", "(", "\"@ie\"", ",", "file", ")", ";", "break", ";", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "fputs", "(", "\"@m\"", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.c", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "powerpcspe", "4", "\"\\t.long\\t\"", "8", "\"@dtprel+0x8000\"", "0", "\"@le\"", "\"@ie\"", "\"@m\"" ]

[]

[ "<s>", "static", "rtx", "get_vl_x2_rtx", "(", "rtx", "avl", ",", "machine_mode", "mode", ",", "machine_mode", "demote_mode", ")", "{", "rtx", "i32vl", "=", "NULL_RTX", ";", "if", "(", "CONST_INT_P", "(", "avl", ")", ")", "{", "unsigned", "elt_size", "=", "GET_MODE_BITSIZE", "(", "GET_MODE_INNER", "(", "mode", ")", ")", ";", "unsigned", "min_size", "=", "get_unknown_min_value", "(", "mode", ")", ";", "unsigned", "vlen_max", "=", "RVV_65536", ";", "unsigned", "vlmax_max", "=", "compute_vlmax", "(", "vlen_max", ",", "elt_size", ",", "min_size", ")", ";", "unsigned", "vlen_min", "=", "TARGET_MIN_VLEN", ";", "unsigned", "vlmax_min", "=", "compute_vlmax", "(", "vlen_min", ",", "elt_size", ",", "min_size", ")", ";", "unsigned", "HOST_WIDE_INT", "avl_int", "=", "INTVAL", "(", "avl", ")", ";", "if", "(", "avl_int", "<=", "vlmax_min", ")", "i32vl", "=", "gen_int_mode", "(", "2", "*", "avl_int", ",", "Pmode", ")", ";", "else", "if", "(", "avl_int", ">=", "2", "*", "vlmax_max", ")", "{", "i32vl", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_no_side_effects_vsetvl_rtx", "(", "demote_mode", ",", "i32vl", ",", "RVV_VLMAX", ")", ")", ";", "}", "else", "{", "}", "}", "if", "(", "!", "i32vl", ")", "{", "rtx", "i64vl", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_no_side_effects_vsetvl_rtx", "(", "mode", ",", "i64vl", ",", "force_reg", "(", "Pmode", ",", "avl", ")", ")", ")", ";", "i32vl", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "i32vl", ",", "gen_rtx_ASHIFT", "(", "Pmode", ",", "i64vl", ",", "const1_rtx", ")", ")", ")", ";", "}", "return", "force_vector_length_operand", "(", "i32vl", ")", ";", "}", "</s>" ]

[ "GET", "VL", "*", "2", "rtx", "." ]

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

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", "Mod", ")", "override", "{", "M", "=", "&", "Mod", ";", "TD", "=", "std", "::", "make_unique", "<", "DataLayout", ">", "(", "M", ")", ";", "SizeTy", "=", "IntegerType", "::", "get", "(", "M", "->", "getContext", "(", ")", ",", "TD", "->", "getIndexSizeInBits", "(", "200", ")", ")", ";", "CapPtrTy", "=", "PointerType", "::", "get", "(", "IntegerType", "::", "get", "(", "M", "->", "getContext", "(", ")", ",", "8", ")", ",", "200", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "200", "8", "200" ]

[]

[ "<s>", "void", "gen_shifty_op", "(", "int", "code", ",", "rtx", "*", "operands", ")", "{", "int", "value", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "int", "max", ",", "i", ";", "value", "=", "value", "&", "31", ";", "if", "(", "value", "==", "31", ")", "{", "if", "(", "code", "==", "LSHIFTRT", ")", "{", "emit_insn", "(", "gen_rotlsi3_1", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "emit_insn", "(", "gen_movt", "(", "operands", "[", "0", "]", ",", "get_t_reg_rtx", "(", ")", ")", ")", ";", "return", ";", "}", "else", "if", "(", "code", "==", "ASHIFT", ")", "{", "if", "(", "REG_P", "(", "operands", "[", "0", "]", ")", "&&", "REGNO", "(", "operands", "[", "0", "]", ")", "==", "0", ")", "{", "emit_insn", "(", "gen_andsi3", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ",", "const1_rtx", ")", ")", ";", "emit_insn", "(", "gen_rotlsi3_31", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "}", "}", "else", "if", "(", "value", "==", "0", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "operands", "[", "0", "]", ")", ")", ";", "return", ";", "}", "max", "=", "ashl_lshr_seq", "[", "value", "]", ".", "insn_count", ";", "for", "(", "i", "=", "0", ";", "i", "<", "max", ";", "i", "++", ")", "gen_ashift", "(", "code", ",", "ashl_lshr_seq", "[", "value", "]", ".", "amount", "[", "i", "]", ",", "operands", "[", "0", "]", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "split", "a", "constant", "shift", "into", "its", "component", "SH", "constant", "shift", "instructions", "." ]

[ "sh", "2", "31", "31", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "int", "c6x_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "int", "dep_type", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ",", "unsigned", "int", ")", "{", "enum", "attr_type", "insn_type", "=", "TYPE_UNKNOWN", ",", "dep_insn_type", "=", "TYPE_UNKNOWN", ";", "int", "dep_insn_code_number", ",", "insn_code_number", ";", "int", "shadow_bonus", "=", "0", ";", "enum", "reg_note", "kind", ";", "dep_insn_code_number", "=", "recog_memoized", "(", "dep_insn", ")", ";", "insn_code_number", "=", "recog_memoized", "(", "insn", ")", ";", "if", "(", "dep_insn_code_number", ">=", "0", ")", "dep_insn_type", "=", "get_attr_type", "(", "dep_insn", ")", ";", "if", "(", "insn_code_number", ">=", "0", ")", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "kind", "=", "(", "reg_note", ")", "dep_type", ";", "if", "(", "kind", "==", "0", ")", "{", "if", "(", "dep_insn_type", "==", "TYPE_LOAD", ")", "{", "rtx", "set", "=", "PATTERN", "(", "dep_insn", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "COND_EXEC", ")", "set", "=", "COND_EXEC_CODE", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "==", "UNSPEC", ")", "cost", "=", "1", ";", "else", "{", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "if", "(", "!", "reg_overlap_mentioned_p", "(", "SET_DEST", "(", "set", ")", ",", "PATTERN", "(", "insn", ")", ")", ")", "cost", "=", "1", ";", "}", "}", "}", "if", "(", "shadow_type_p", "(", "insn_type", ")", ")", "shadow_bonus", "=", "1", ";", "if", "(", "kind", "!=", "0", ")", "{", "if", "(", "kind", "==", "REG_DEP_ANTI", "&&", "insn_type", "==", "TYPE_SHADOW", ")", "kind", "=", "REG_DEP_OUTPUT", ";", "switch", "(", "dep_insn_type", ")", "{", "case", "TYPE_CALLP", ":", "return", "1", ";", "case", "TYPE_BRANCH", ":", "case", "TYPE_CALL", ":", "if", "(", "get_attr_has_shadow", "(", "dep_insn", ")", "==", "HAS_SHADOW_Y", ")", "return", "0", ";", "return", "6", ";", "case", "TYPE_LOAD", ":", "case", "TYPE_LOADN", ":", "case", "TYPE_INTDP", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "5", "-", "shadow_bonus", ";", "return", "0", ";", "case", "TYPE_MPY4", ":", "case", "TYPE_FP4", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "4", "-", "shadow_bonus", ";", "return", "0", ";", "case", "TYPE_MPY2", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "2", "-", "shadow_bonus", ";", "return", "0", ";", "case", "TYPE_CMPDP", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "2", "-", "shadow_bonus", ";", "return", "2", ";", "case", "TYPE_ADDDP", ":", "case", "TYPE_MPYSPDP", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "7", "-", "shadow_bonus", ";", "return", "2", ";", "case", "TYPE_MPYSP2DP", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "5", "-", "shadow_bonus", ";", "return", "2", ";", "case", "TYPE_MPYI", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "9", "-", "shadow_bonus", ";", "return", "4", ";", "case", "TYPE_MPYID", ":", "case", "TYPE_MPYDP", ":", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "10", "-", "shadow_bonus", ";", "return", "4", ";", "default", ":", "if", "(", "insn_type", "==", "TYPE_SPKERNEL", ")", "return", "0", ";", "if", "(", "kind", "==", "REG_DEP_OUTPUT", ")", "return", "1", "-", "shadow_bonus", ";", "return", "0", ";", "}", "}", "return", "cost", "-", "shadow_bonus", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_SCHED_ADJUST_COST", "hook", ".", "We", "need", "special", "handling", "for", "anti-", "and", "output", "dependencies", "." ]

[ "c6x", "0", "0", "0", "0", "1", "1", "1", "0", "1", "0", "6", "5", "0", "4", "0", "2", "0", "2", "2", "7", "2", "5", "2", "9", "4", "10", "4", "0", "1", "0" ]

[]

[ "<s>", "bool", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "const", "{", "return", "LowerZ80MachineOperandToMCOperand", "(", "MO", ",", "MCOp", ",", "*", "this", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "void", "v850_output_aligned_bss", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "unsigned", "HOST_WIDE_INT", "size", ",", "int", "align", ")", "{", "switch", "(", "v850_get_data_area", "(", "decl", ")", ")", "{", "case", "DATA_AREA_ZDA", ":", "switch_to_section", "(", "zbss_section", ")", ";", "break", ";", "case", "DATA_AREA_SDA", ":", "switch_to_section", "(", "sbss_section", ")", ";", "break", ";", "case", "DATA_AREA_TDA", ":", "switch_to_section", "(", "tdata_section", ")", ";", "break", ";", "default", ":", "switch_to_section", "(", "bss_section", ")", ";", "break", ";", "}", "ASM_OUTPUT_ALIGN", "(", "file", ",", "floor_log2", "(", "align", "/", "BITS_PER_UNIT", ")", ")", ";", "last_assemble_variable_decl", "=", "decl", ";", "ASM_DECLARE_OBJECT_NAME", "(", "file", ",", "name", ",", "decl", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "name", ")", ";", "ASM_OUTPUT_SKIP", "(", "file", ",", "size", "?", "size", ":", "1", ")", ";", "}", "</s>" ]

[ "A", "version", "of", "asm_output_aligned_bss", "(", ")", "that", "copes", "with", "the", "special", "data", "areas", "of", "the", "v850", "." ]

[ "v850", "1" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "optimizeCompareInstr", "(", "MachineInstr", "*", "Compare", ",", "unsigned", "SrcReg", ",", "unsigned", "SrcReg2", ",", "int", "Mask", ",", "int", "Value", ",", "const", "MachineRegisterInfo", "*", "MRI", ")", "const", "{", "assert", "(", "!", "SrcReg2", "&&", "\"Only optimizing constant comparisons so far\"", ")", ";", "bool", "IsLogical", "=", "(", "Compare", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "SystemZII", "::", "IsLogical", ")", "!=", "0", ";", "if", "(", "Value", "==", "0", "&&", "!", "IsLogical", "&&", "removeIPMBasedCompare", "(", "Compare", ",", "SrcReg", ",", "MRI", ",", "TM", ".", "getRegisterInfo", "(", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "optimizeCompareInstr", "-", "Check", "if", "there", "exists", "an", "earlier", "instruction", "that", "operates", "on", "the", "same", "source", "operands", "and", "sets", "flags", "in", "the", "same", "way", "as", "Compare", ";", "remove", "Compare", "if", "possible", "." ]

[ "SystemZ", "SystemZ", "\"Only optimizing constant comparisons so far\"", "SystemZII::IsLogical", "0", "0" ]

[]

[ "<s>", "bool", "swiftAsyncContextIsDynamicallySet", "(", ")", "const", "{", "const", "Triple", "&", "TT", "=", "getTargetTriple", "(", ")", ";", "unsigned", "Major", "=", "TT", ".", "getOSVersion", "(", ")", ".", "getMajor", "(", ")", ";", "switch", "(", "TT", ".", "getOS", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Triple", "::", "IOS", ":", "case", "Triple", "::", "TvOS", ":", "return", "Major", "<", "15", ";", "case", "Triple", "::", "WatchOS", ":", "return", "Major", "<", "8", ";", "case", "Triple", "::", "MacOSX", ":", "case", "Triple", "::", "Darwin", ":", "return", "Major", "<", "12", ";", "}", "}", "</s>" ]

[ "Return", "whether", "FrameLowering", "should", "always", "set", "the", "``", "extended", "frame", "present", "''", "bit", "in", "FP", ",", "or", "set", "it", "based", "on", "a", "symbol", "in", "the", "runtime", "." ]

[ "AArch64", "15", "8", "12" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "const", "Triple", "&", "TT", "=", "TM", ".", "getTargetTriple", "(", ")", ";", "StringRef", "CPU", "=", "TM", ".", "getTargetCPU", "(", ")", ";", "StringRef", "FS", "=", "TM", ".", "getTargetFeatureString", "(", ")", ";", "const", "NVPTXTargetMachine", "&", "NTM", "=", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "TM", ")", ";", "const", "NVPTXSubtarget", "STI", "(", "TT", ",", "CPU", ",", "FS", ",", "NTM", ")", ";", "if", "(", "M", ".", "alias_size", "(", ")", ")", "{", "report_fatal_error", "(", "\"Module has aliases, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "isEmptyXXStructor", "(", "M", ".", "getNamedGlobal", "(", "\"llvm.global_ctors\"", ")", ")", ")", "{", "report_fatal_error", "(", "\"Module has a nontrivial global ctor, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "if", "(", "!", "isEmptyXXStructor", "(", "M", ".", "getNamedGlobal", "(", "\"llvm.global_dtors\"", ")", ")", ")", "{", "report_fatal_error", "(", "\"Module has a nontrivial global dtor, which NVPTX does not support.\"", ")", ";", "return", "true", ";", "}", "SmallString", "<", "128", ">", "Str1", ";", "raw_svector_ostream", "OS1", "(", "Str1", ")", ";", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "const_cast", "<", "TargetLoweringObjectFile", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ".", "Initialize", "(", "OutContext", ",", "TM", ")", ";", "Mang", "=", "new", "Mangler", "(", ")", ";", "emitHeader", "(", "M", ",", "OS1", ",", "STI", ")", ";", "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", "(", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "!=", "Triple", "::", "NVCL", ")", "recordAndEmitFilenames", "(", "M", ")", ";", "GlobalsEmitted", "=", "false", ";", "return", "false", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "\"Module has aliases, which NVPTX does not support.\"", "\"llvm.global_ctors\"", "\"Module has a nontrivial global ctor, which NVPTX does not support.\"", "\"llvm.global_dtors\"", "\"Module has a nontrivial global dtor, which NVPTX does not support.\"", "128", "\"Start of file scope inline assembly\"", "\"End of file scope inline assembly\"" ]

[]

[ "<s>", "void", "WebAssemblyDebugValueManager", "::", "clone", "(", "MachineInstr", "*", "Insert", ",", "unsigned", "NewReg", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "Insert", "->", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "for", "(", "MachineInstr", "*", "DBI", ":", "reverse", "(", "DbgValues", ")", ")", "{", "MachineInstr", "*", "Clone", "=", "MF", "->", "CloneMachineInstr", "(", "DBI", ")", ";", "Clone", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "NewReg", ")", ";", "MBB", "->", "insert", "(", "Insert", ",", "Clone", ")", ";", "}", "}", "</s>" ]

[ "Make", "a", "functionally", "equivalent", "copy", "of", "this", "MachineFunctionInfo", "in", "MF", "." ]

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

[]