Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "MachineInstrBuilder", "MipsInstrInfo", "::", "genInstrWithNewOpc", "(", "unsigned", "NewOpc", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstrBuilder", "MIB", ";", "bool", "BranchWithZeroOperand", "=", "(", "I", "->", "isBranch", "(", ")", "&&", "!", "I", "->", "isPseudo", "(", ")", "&&", "I", "->", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO", "||", "I", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO_64", ")", ")", ";", "if", "(", "BranchWithZeroOperand", ")", "{", "switch", "(", "NewOpc", ")", "{", "case", "Mips", "::", "BEQC", ":", "NewOpc", "=", "Mips", "::", "BEQZC", ";", "break", ";", "case", "Mips", "::", "BNEC", ":", "NewOpc", "=", "Mips", "::", "BNEZC", ";", "break", ";", "case", "Mips", "::", "BGEC", ":", "NewOpc", "=", "Mips", "::", "BGEZC", ";", "break", ";", "case", "Mips", "::", "BLTC", ":", "NewOpc", "=", "Mips", "::", "BLTZC", ";", "break", ";", "}", "}", "MIB", "=", "BuildMI", "(", "*", "I", "->", "getParent", "(", ")", ",", "I", ",", "I", "->", "getDebugLoc", "(", ")", ",", "get", "(", "NewOpc", ")", ")", ";", "if", "(", "NewOpc", "==", "Mips", "::", "JIC", "||", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIC64", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "{", "if", "(", "NewOpc", "==", "Mips", "::", "JIALC", "||", "NewOpc", "==", "Mips", "::", "JIALC64", ")", "MIB", "->", "RemoveOperand", "(", "0", ")", ";", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "MIB", ".", "addOperand", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "MIB", ".", "addImm", "(", "0", ")", ";", "}", "else", "if", "(", "BranchWithZeroOperand", ")", "{", "MIB", ".", "addOperand", "(", "I", "->", "getOperand", "(", "0", ")", ")", ";", "for", "(", "unsigned", "J", "=", "2", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "MIB", ".", "addOperand", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "}", "else", "{", "for", "(", "unsigned", "J", "=", "0", ",", "E", "=", "I", "->", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", ";", "J", "<", "E", ";", "++", "J", ")", "{", "MIB", ".", "addOperand", "(", "I", "->", "getOperand", "(", "J", ")", ")", ";", "}", "}", "MIB", ".", "copyImplicitOps", "(", "*", "I", ")", ";", "MIB", ".", "setMemRefs", "(", "I", "->", "memoperands_begin", "(", ")", ",", "I", "->", "memoperands_end", "(", ")", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "Create", "an", "instruction", "which", "has", "the", "same", "operands", "and", "memory", "operands", "as", "MI", "but", "has", "a", "new", "opcode", "." ]

[ "Mips", "Mips", "1", "1", "Mips::ZERO", "1", "Mips::ZERO_64", "Mips::BEQC", "Mips::BEQZC", "Mips::BNEC", "Mips::BNEZC", "Mips::BGEC", "Mips::BGEZC", "Mips::BLTC", "Mips::BLTZC", "Mips::JIC", "Mips::JIALC", "Mips::JIC64", "Mips::JIALC64", "Mips::JIALC", "Mips::JIALC64", "0", "0", "0", "0", "2", "0" ]

[]

[ "<s>", "void", "BT", "::", "reset", "(", ")", "{", "EdgeExec", ".", "clear", "(", ")", ";", "InstrExec", ".", "clear", "(", ")", ";", "Map", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "new", "X86ExecutionDomainFix", "(", ")", ")", ";", "addPass", "(", "createBreakFalseDeps", "(", ")", ")", ";", "}", "addPass", "(", "createX86IndirectBranchTrackingPass", "(", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupBWInsts", "(", ")", ")", ";", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "addPass", "(", "createX86EvexToVexInsts", "(", ")", ")", ";", "}", "addPass", "(", "createX86DiscriminateMemOpsPass", "(", ")", ")", ";", "addPass", "(", "createX86InsertPrefetchPass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "M88kInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "assert", "(", "Cond", ".", "size", "(", ")", "==", "3", "&&", "\"wrong number of m88k branch conditions\"", ")", ";", "switch", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "case", "M88k", "::", "BCND", ":", "Cond", "[", "1", "]", ".", "setImm", "(", "~", "Cond", "[", "1", "]", ".", "getImm", "(", ")", "&", "0x0f", ")", ";", "break", ";", "case", "M88k", "::", "BB1", ":", "case", "M88k", "::", "BB0", ":", "{", "unsigned", "CC", "=", "Cond", "[", "1", "]", ".", "getImm", "(", ")", ";", "CC", "=", "(", "CC", "&", "~", "1", ")", "|", "(", "1", "-", "(", "CC", "&", "0x01", ")", ")", ";", "Cond", "[", "1", "]", ".", "setImm", "(", "CC", ")", ";", "break", ";", "}", "default", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Reverses", "the", "branch", "condition", "of", "the", "specified", "condition", "list", ",", "returning", "false", "on", "success", "and", "true", "if", "it", "can", "not", "be", "reversed", "." ]

[ "M88k", "M88k", "3", "\"wrong number of m88k branch conditions\"", "0", "M88k::BCND", "1", "1", "0x0f", "M88k::BB1", "M88k::BB0", "1", "1", "1", "0x01", "1" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isPredicated", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "int", "idx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "idx", "<", "0", ")", "return", "false", ";", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "idx", ")", ".", "getReg", "(", ")", ";", "switch", "(", "Reg", ")", "{", "default", ":", "return", "false", ";", "case", "AMDGPU", "::", "PRED_SEL_ONE", ":", "case", "AMDGPU", "::", "PRED_SEL_ZERO", ":", "case", "AMDGPU", "::", "PREDICATE_BIT", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "R600", "0" ]

[]

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

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

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

[]

[ "<s>", "const", "char", "*", "nds32_output_tls_desc", "(", "rtx", "*", "operands", ")", "{", "char", "pattern", "[", "1000", "]", ";", "if", "(", "TARGET_RELAX_HINT", ")", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\".relax_hint %%1\\n\\tsethi $r0, hi20(%%0)\\n\\t\"", "\".relax_hint %%1\\n\\tori $r0, $r0, lo12(%%0)\\n\\t\"", "\".relax_hint %%1\\n\\tlw $r15, [$r0 + $gp]\\n\\t\"", "\".relax_hint %%1\\n\\tadd $r0, $r0, $gp\\n\\t\"", "\".relax_hint %%1\\n\\tjral $r15\"", ")", ";", "else", "snprintf", "(", "pattern", ",", "sizeof", "(", "pattern", ")", ",", "\"sethi $r0, hi20(%%0)\\n\\t\"", "\"ori $r0, $r0, lo12(%%0)\\n\\t\"", "\"lw $r15, [$r0 + $gp]\\n\\t\"", "\"add $r0, $r0, $gp\\n\\t\"", "\"jral $r15\"", ")", ";", "output_asm_insn", "(", "pattern", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Auxiliary", "function", "for", "output", "TLS", "patterns", "." ]

[ "nds32", "1000", "\".relax_hint %%1\\n\\tsethi $r0, hi20(%%0)\\n\\t\"", "\".relax_hint %%1\\n\\tori $r0, $r0, lo12(%%0)\\n\\t\"", "\".relax_hint %%1\\n\\tlw $r15, [$r0 + $gp]\\n\\t\"", "\".relax_hint %%1\\n\\tadd $r0, $r0, $gp\\n\\t\"", "\".relax_hint %%1\\n\\tjral $r15\"", "\"sethi $r0, hi20(%%0)\\n\\t\"", "\"ori $r0, $r0, lo12(%%0)\\n\\t\"", "\"lw $r15, [$r0 + $gp]\\n\\t\"", "\"add $r0, $r0, $gp\\n\\t\"", "\"jral $r15\"", "\"\"" ]

[]

[ "<s>", "static", "void", "moxie_compute_frame", "(", "void", ")", "{", "int", "stack_alignment", "=", "STACK_BOUNDARY", "/", "BITS_PER_UNIT", ";", "int", "padding_locals", ";", "int", "regno", ";", "cfun", "->", "machine", "->", "local_vars_size", "=", "get_frame_size", "(", ")", ";", "padding_locals", "=", "cfun", "->", "machine", "->", "local_vars_size", "%", "stack_alignment", ";", "if", "(", "padding_locals", ")", "padding_locals", "=", "stack_alignment", "-", "padding_locals", ";", "cfun", "->", "machine", "->", "local_vars_size", "+=", "padding_locals", ";", "cfun", "->", "machine", "->", "callee_saved_reg_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "(", "!", "call_used_regs", "[", "regno", "]", ")", ")", "cfun", "->", "machine", "->", "callee_saved_reg_size", "+=", "4", ";", "cfun", "->", "machine", "->", "size_for_adjusting_sp", "=", "crtl", "->", "args", ".", "pretend_args_size", "+", "cfun", "->", "machine", "->", "local_vars_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "crtl", "->", "outgoing_args_size", ":", "0", ")", ";", "}", "</s>" ]

[ "Compute", "the", "size", "of", "the", "local", "area", "and", "the", "size", "to", "be", "adjusted", "by", "the", "*", "prologue", "and", "epilogue", "." ]

[ "moxie", "0", "0", "4", "0" ]

[]

[ "<s>", "RISCVTargetLowering", "::", "ConstraintType", "RISCVTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'f'", ":", "case", "'v'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "return", "C_Immediate", ";", "case", "'A'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "1", "0" ]

[]

[ "<s>", "bool", "M680x0AsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "getRelaxedOpcodeBranch", "(", "Inst", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ")", "return", "true", ";", "if", "(", "getRelaxedOpcodeArith", "(", "Inst", ")", "==", "Inst", ".", "getOpcode", "(", ")", ")", "return", "false", ";", "unsigned", "RelaxableOp", "=", "Inst", ".", "getNumOperands", "(", ")", "-", "1", ";", "if", "(", "Inst", ".", "getOperand", "(", "RelaxableOp", ")", ".", "isExpr", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "1" ]

[]

[ "<s>", "bool", "PPCCTRLoops", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "LI", "=", "&", "getAnalysis", "<", "LoopInfo", ">", "(", ")", ";", "SE", "=", "&", "getAnalysis", "<", "ScalarEvolution", ">", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTree", ">", "(", ")", ";", "TD", "=", "getAnalysisIfAvailable", "<", "DataLayout", ">", "(", ")", ";", "LibInfo", "=", "getAnalysisIfAvailable", "<", "TargetLibraryInfo", ">", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "LoopInfo", "::", "iterator", "I", "=", "LI", "->", "begin", "(", ")", ",", "E", "=", "LI", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Loop", "*", "L", "=", "*", "I", ";", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "MadeChange", "|=", "convertToCTRLoop", "(", "L", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "void", "csky_reorg", "(", "void", ")", "{", "if", "(", "TARGET_CONSTANT_POOL", ")", "csky_emit_constant_pools", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MACHINE_DEPENDENT_REORG", ".", "This", "handles", "-mconstpool", "output", "." ]

[ "csky" ]

[]

[ "<s>", "static", "void", "*", "ia64_alloc_sched_context", "(", "void", ")", "{", "return", "xmalloc", "(", "sizeof", "(", "struct", "_ia64_sched_context", ")", ")", ";", "}", "</s>" ]

[ "Allocates", "a", "scheduling", "context", "." ]

[ "ia64" ]

[]

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

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

[ "Cpu0" ]

[]

[ "<s>", "static", "bool", "sh_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "1", "&&", "!", "sh_cfun_interrupt_handler_p", "(", ")", "&&", "(", "!", "flag_pic", "||", "TARGET_FDPIC", "||", "(", "decl", "&&", "!", "(", "TREE_PUBLIC", "(", "decl", ")", "||", "DECL_WEAK", "(", "decl", ")", ")", ")", "||", "(", "decl", "&&", "DECL_VISIBILITY", "(", "decl", ")", "!=", "VISIBILITY_DEFAULT", ")", ")", ")", ";", "}", "</s>" ]

[ "If", "PIC", ",", "we", "can", "not", "make", "sibling", "calls", "to", "global", "functions", "because", "the", "PLT", "requires", "r12", "to", "be", "live", "." ]

[ "sh", "1" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "findCommutedOpIndices", "(", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcOpIdx1", ",", "unsigned", "&", "SrcOpIdx2", ")", "const", "{", "assert", "(", "!", "MI", ".", "isBundle", "(", ")", "&&", "\"TargetInstrInfo::findCommutedOpIndices() can't handle bundles\"", ")", ";", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "!", "MCID", ".", "isCommutable", "(", ")", ")", "return", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Mips", "::", "DPADD_U_H", ":", "case", "Mips", "::", "DPADD_U_W", ":", "case", "Mips", "::", "DPADD_U_D", ":", "case", "Mips", "::", "DPADD_S_H", ":", "case", "Mips", "::", "DPADD_S_W", ":", "case", "Mips", "::", "DPADD_S_D", ":", "if", "(", "!", "fixCommutedOpIndices", "(", "SrcOpIdx1", ",", "SrcOpIdx2", ",", "2", ",", "3", ")", ")", "return", "false", ";", "if", "(", "!", "MI", ".", "getOperand", "(", "SrcOpIdx1", ")", ".", "isReg", "(", ")", "||", "!", "MI", ".", "getOperand", "(", "SrcOpIdx2", ")", ".", "isReg", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "return", "TargetInstrInfo", "::", "findCommutedOpIndices", "(", "MI", ",", "SrcOpIdx1", ",", "SrcOpIdx2", ")", ";", "}", "</s>" ]

[ "Returns", "true", "iff", "the", "routine", "could", "find", "two", "commutable", "operands", "in", "the", "given", "machine", "instruction", "." ]

[ "Mips", "Mips", "\"TargetInstrInfo::findCommutedOpIndices() can't handle bundles\"", "Mips::DPADD_U_H", "Mips::DPADD_U_W", "Mips::DPADD_U_D", "Mips::DPADD_S_H", "Mips::DPADD_S_W", "Mips::DPADD_S_D", "2", "3" ]

[]

[ "<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", ")", "{", "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.attributes\"", "ARM", "0" ]

[]

[ "<s>", "void", "MipsTargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">>", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "if", "(", "IsPICCall", "&&", "!", "InternalLinkage", "&&", "IsCallReloc", "&&", "!", "ABI", ".", "IsCheriPureCap", "(", ")", ")", "{", "unsigned", "GPReg", "=", "ABI", ".", "IsN64", "(", ")", "?", "Mips", "::", "GP_64", ":", "Mips", "::", "GP", ";", "EVT", "Ty", "=", "ABI", ".", "IsN64", "(", ")", "?", "MVT", "::", "i64", ":", "MVT", "::", "i32", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPReg", ",", "getGlobalReg", "(", "CLI", ".", "DAG", ",", "Ty", ",", "false", ")", ")", ")", ";", "}", "SDValue", "InFlag", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Chain", "=", "CLI", ".", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "CLI", ".", "DL", ",", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ",", "InFlag", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RegsToPass", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegister", "(", "RegsToPass", "[", "i", "]", ".", "first", ",", "RegsToPass", "[", "i", "]", ".", "second", ".", "getValueType", "(", ")", ")", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "DAG", ".", "getMachineFunction", "(", ")", ",", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "\"Missing call preserved mask for calling convention\"", ")", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "\"__Mips16RetHelper\"", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}", "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";", "if", "(", "InFlag", ".", "getNode", "(", ")", ")", "Ops", ".", "push_back", "(", "InFlag", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

[ "Mips", "Mips", "Mips::GP_64", "Mips::GP", "MVT::i64", "MVT::i32", "0", "1", "0", "\"Missing call preserved mask for calling convention\"", "Mips", "\"__Mips16RetHelper\"", "Mips", "Mips" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "unsigned", "ValVReg", ",", "unsigned", "PhysReg", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value shouldn't be assigned to reg\"", ")", ";", "assert", "(", "VA", ".", "getLocReg", "(", ")", "==", "PhysReg", "&&", "\"Assigning to the wrong reg?\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "64", "&&", "\"Unsupported value size\"", ")", ";", "assert", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", "<=", "64", "&&", "\"Unsupported location size\"", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "ARM", "\"Value shouldn't be assigned to reg\"", "\"Assigning to the wrong reg?\"", "64", "\"Unsupported value size\"", "64", "\"Unsupported location size\"" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "pa_output_millicode_call", "(", "rtx_insn", "*", "insn", ",", "rtx", "call_dest", ")", "{", "int", "attr_length", "=", "get_attr_length", "(", "insn", ")", ";", "int", "seq_length", "=", "dbr_sequence_length", "(", ")", ";", "rtx", "xoperands", "[", "3", "]", ";", "xoperands", "[", "0", "]", "=", "call_dest", ";", "xoperands", "[", "2", "]", "=", "gen_rtx_REG", "(", "Pmode", ",", "TARGET_64BIT", "?", "2", ":", "31", ")", ";", "if", "(", "!", "TARGET_LONG_CALLS", "&&", "(", "attr_length", "==", "8", "||", "(", "attr_length", "==", "28", "&&", "get_attr_type", "(", "insn", ")", "==", "TYPE_SH_FUNC_ADRS", ")", ")", ")", "{", "output_asm_insn", "(", "\"{bl|b,l} %0,%2\"", ",", "xoperands", ")", ";", "}", "else", "{", "if", "(", "TARGET_64BIT", ")", "{", "output_asm_insn", "(", "\"b,l .+8,%%r1\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_GAS", ")", "{", "output_asm_insn", "(", "\"addil L'%0-$PIC_pcrel$0+4,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "else", "{", "xoperands", "[", "1", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_insn", "(", "\"addil L'%0-%l1,%%r1\"", ",", "xoperands", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "xoperands", "[", "1", "]", ")", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-%l1(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "output_asm_insn", "(", "\"bve,l (%%r1),%%r2\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0(%%r1),%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"{bl|b,l} .+8,%%r31\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"addi 8,%%r31,%%r31\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "!", "flag_pic", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_PA_20", ")", "output_asm_insn", "(", "\"be,l R'%0(%%sr4,%%r1),%%sr0,%%r31\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"ble R'%0(%%sr4,%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"{bl|b,l} .+8,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"addi 16,%%r1,%%r31\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_SOM", "||", "!", "TARGET_GAS", ")", "{", "xoperands", "[", "1", "]", "=", "gen_label_rtx", "(", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "xoperands", "[", "1", "]", ")", ")", ";", "output_asm_insn", "(", "\"addil L'%0-%l1,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-%l1(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"addil L'%0-$PIC_pcrel$0+8,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0-$PIC_pcrel$0+12(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "}", "if", "(", "seq_length", "==", "0", ")", "output_asm_insn", "(", "\"nop\"", ",", "xoperands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "INSN", "is", "a", "function", "call", ".", "CALL_DEST", "is", "the", "routine", "we", "are", "calling", "." ]

[ "pa", "3", "0", "2", "2", "31", "8", "28", "\"{bl|b,l} %0,%2\"", "\"b,l .+8,%%r1\"", "\"addil L'%0-$PIC_pcrel$0+4,%%r1\"", "\"ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1\"", "1", "\"addil L'%0-%l1,%%r1\"", "\"L\"", "1", "\"ldo R'%0-%l1(%%r1),%%r1\"", "\"bve,l (%%r1),%%r2\"", "\"ldil L'%0,%%r1\"", "\"ldo R'%0(%%r1),%%r1\"", "\"{bl|b,l} .+8,%%r31\"", "\"addi 8,%%r31,%%r31\"", "\"bv %%r0(%%r1)\"", "\"ldil L'%0,%%r1\"", "\"be,l R'%0(%%sr4,%%r1),%%sr0,%%r31\"", "\"ble R'%0(%%sr4,%%r1)\"", "\"{bl|b,l} .+8,%%r1\"", "\"addi 16,%%r1,%%r31\"", "1", "\"L\"", "1", "\"addil L'%0-%l1,%%r1\"", "\"ldo R'%0-%l1(%%r1),%%r1\"", "\"addil L'%0-$PIC_pcrel$0+8,%%r1\"", "\"ldo R'%0-$PIC_pcrel$0+12(%%r1),%%r1\"", "\"bv %%r0(%%r1)\"", "0", "\"nop\"", "\"\"" ]

[]

[ "<s>", "static", "rtx", "arc_legitimize_address_0", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "addr", ",", "inner", ";", "addr", "=", "x", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&&", "(", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "||", "(", "REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "&&", "(", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "&", "252", ")", ")", ")", ")", "{", "HOST_WIDE_INT", "offs", ",", "upper", ";", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "offs", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "upper", "=", "(", "offs", "+", "256", "*", "size", ")", "&", "~", "511", "*", "size", ";", "inner", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "addr", ",", "0", ")", ",", "upper", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", ")", "inner", "=", "gen_rtx_CONST", "(", "Pmode", ",", "inner", ")", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "inner", ")", ",", "offs", "-", "upper", ")", ";", "x", "=", "addr", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "&&", "!", "SYMBOL_REF_FUNCTION_P", "(", "addr", ")", ")", "x", "=", "force_reg", "(", "Pmode", ",", "x", ")", ";", "if", "(", "memory_address_p", "(", "(", "machine_mode", ")", "mode", ",", "x", ")", ")", "return", "x", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "This", "is", "like", "the", "hook", ",", "but", "returns", "NULL", "when", "it", "ca", "n't", "/", "wo", "n't", "generate", "a", "legitimate", "address", "." ]

[ "arc", "0", "1", "0", "0", "0", "1", "252", "1", "256", "511", "0" ]

[]

[ "<s>", "static", "rtx", "sparc_got", "(", "void", ")", "{", "if", "(", "!", "got_symbol_rtx", ")", "got_symbol_rtx", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ")", ";", "return", "got_symbol_rtx", ";", "}", "</s>" ]

[ "Return", "the", "SYMBOL_REF", "for", "the", "Global", "Offset", "Table", "." ]

[ "sparc", "\"_GLOBAL_OFFSET_TABLE_\"" ]

[]

[ "<s>", "static", "void", "init_insn_group_barriers", "(", ")", "{", "memset", "(", "rws_sum", ",", "0", ",", "sizeof", "(", "rws_sum", ")", ")", ";", "first_instruction", "=", "1", ";", "}", "</s>" ]

[ "Clear", "out", "the", "state", "for", "group_barrier_needed_p", "at", "the", "start", "of", "a", "sequence", "of", "insns", "." ]

[ "ia64", "0", "1" ]

[]

[ "<s>", "const", "WebAssemblySubtarget", "*", "WebAssemblyTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "WebAssemblySubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"target-cpu\"", "\"target-features\"", "WebAssembly" ]

[]

[ "<s>", "const", "CallLowering", "*", "PPCSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "return", "CallLoweringInfo", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Methods", "used", "by", "Global", "ISel", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "AlphaAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "this", "->", "MF", "=", "&", "MF", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "F", ",", "Mang", ",", "TM", ")", ")", ";", "EmitAlignment", "(", "MF", ".", "getAlignment", "(", ")", ",", "F", ")", ";", "switch", "(", "F", "->", "getLinkage", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown linkage type!\"", ")", ";", "case", "Function", "::", "InternalLinkage", ":", "case", "Function", "::", "PrivateLinkage", ":", "case", "Function", "::", "LinkerPrivateLinkage", ":", "break", ";", "case", "Function", "::", "ExternalLinkage", ":", "O", "<<", "\"\\t.globl \"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "break", ";", "case", "Function", "::", "WeakAnyLinkage", ":", "case", "Function", "::", "WeakODRLinkage", ":", "case", "Function", "::", "LinkOnceAnyLinkage", ":", "case", "Function", "::", "LinkOnceODRLinkage", ":", "O", "<<", "TAI", "->", "getWeakRefDirective", "(", ")", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "break", ";", "}", "printVisibility", "(", "CurrentFnName", ",", "F", "->", "getVisibility", "(", ")", ")", ";", "O", "<<", "\"\\t.ent \"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "O", "<<", "CurrentFnName", "<<", "\":\\n\"", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "MF", ".", "begin", "(", ")", ")", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "E", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "E", ";", "++", "II", ")", "{", "++", "EmittedInsts", ";", "printInstruction", "(", "II", ")", ";", "}", "}", "O", "<<", "\"\\t.end \"", "<<", "CurrentFnName", "<<", "\"\\n\"", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "\"\\n\\n\"", "\"Unknown linkage type!\"", "\"\\t.globl \"", "\"\\n\"", "\"\\n\"", "\"\\t.ent \"", "\"\\n\"", "\":\\n\"", "\"\\t.end \"", "\"\\n\"" ]

[]

[ "<s>", "static", "rtx", "lxvrze_expand_builtin", "(", "rtx", "target", ",", "insn_code", "icode", ",", "rtx", "*", "op", ",", "machine_mode", "tmode", ",", "machine_mode", "smode", ")", "{", "rtx", "pat", ",", "addr", ";", "op", "[", "1", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "1", "]", ")", ";", "if", "(", "op", "[", "0", "]", "==", "const0_rtx", ")", "addr", "=", "gen_rtx_MEM", "(", "tmode", ",", "op", "[", "1", "]", ")", ";", "else", "{", "op", "[", "0", "]", "=", "copy_to_mode_reg", "(", "Pmode", ",", "op", "[", "0", "]", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "smode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "op", "[", "1", "]", ",", "op", "[", "0", "]", ")", ")", ";", "}", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "target", ",", "addr", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Expand", "a", "builtin", "function", "that", "loads", "a", "scalar", "into", "a", "vector", "register", "with", "zero", "extension", ",", "and", "return", "the", "expanded", "rtx", "." ]

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

[]

[ "<s>", "bool", "mmix_legitimate_address_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "bool", "strict_checking", ")", "{", "(", "(", "strict_checking", "\\", "&&", "(", "REGNO", "(", "X", ")", "<=", "MMIX_LAST_GENERAL_REGISTER", "\\", "||", "(", "reg_renumber", "[", "REGNO", "(", "X", ")", "]", ">", "0", "\\", "&&", "reg_renumber", "[", "REGNO", "(", "X", ")", "]", "<=", "MMIX_LAST_GENERAL_REGISTER", ")", ")", ")", "\\", "||", "(", "!", "strict_checking", "\\", "&&", "(", "REGNO", "(", "X", ")", "<=", "MMIX_LAST_GENERAL_REGISTER", "\\", "||", "REGNO", "(", "X", ")", ">=", "FIRST_PSEUDO_REGISTER", "\\", "||", "REGNO", "(", "X", ")", "==", "ARG_POINTER_REGNUM", ")", ")", ")", "if", "(", "REG_P", "(", "x", ")", "&&", "MMIX_REG_OK", "(", "x", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "rtx", "x1", "=", "XEXP", "(", "x", ",", "0", ")", ";", "rtx", "x2", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "x1", ")", ")", "{", "rtx", "tem", "=", "x1", ";", "x1", "=", "x2", ";", "x2", "=", "tem", ";", "}", "if", "(", "!", "REG_P", "(", "x1", ")", "||", "!", "MMIX_REG_OK", "(", "x1", ")", ")", "return", "TARGET_BASE_ADDRESSES", "&&", "mmix_constant_address_p", "(", "x", ")", ";", "if", "(", "REG_P", "(", "x2", ")", "&&", "MMIX_REG_OK", "(", "x2", ")", ")", "return", "1", ";", "if", "(", "satisfies_constraint_I", "(", "x2", ")", ")", "return", "1", ";", "return", "0", ";", "}", "return", "TARGET_BASE_ADDRESSES", "&&", "mmix_constant_address_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "address", "is", "OK", ",", "otherwise", "0", "." ]

[ "mmix", "0", "1", "0", "1", "1", "1", "0" ]

[]

[ "<s>", "const", "char", "*", "SITargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "Opcode", ")", ";", "NODE_NAME_CASE", "(", "VCC_AND", ")", "NODE_NAME_CASE", "(", "VCC_BITCAST", ")", "}", "}", "</s>" ]

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

[ "R600", "SI" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "NVPTX" ]

[]

[ "<s>", "MCSymbol", "*", "AArch64AsmPrinter", "::", "GetCPISymbol", "(", "unsigned", "CPID", ")", "const", "{", "if", "(", "getDataLayout", "(", ")", ".", "getLinkerPrivateGlobalPrefix", "(", ")", "[", "0", "]", ")", "return", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "getDataLayout", "(", ")", ".", "getLinkerPrivateGlobalPrefix", "(", ")", ")", "+", "\"CPI\"", "+", "Twine", "(", "getFunctionNumber", "(", ")", ")", "+", "\"_\"", "+", "Twine", "(", "CPID", ")", ")", ";", "return", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "getDataLayout", "(", ")", ".", "getPrivateGlobalPrefix", "(", ")", ")", "+", "\"CPI\"", "+", "Twine", "(", "getFunctionNumber", "(", ")", ")", "+", "\"_\"", "+", "Twine", "(", "CPID", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "symbol", "for", "the", "specified", "constant", "pool", "entry", "." ]

[ "AArch64", "AArch64", "0", "\"CPI\"", "\"_\"", "\"CPI\"", "\"_\"" ]

[]

[ "<s>", "static", "void", "emit_pic_helper", "(", "void", ")", "{", "const", "char", "*", "pic_name", "=", "reg_names", "[", "REGNO", "(", "pic_offset_table_rtx", ")", "]", ";", "int", "align", ";", "text_section", "(", ")", ";", "align", "=", "floor_log2", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", ")", ";", "if", "(", "align", ">", "0", ")", "ASM_OUTPUT_ALIGN", "(", "asm_out_file", ",", "align", ")", ";", "ASM_OUTPUT_LABEL", "(", "asm_out_file", ",", "pic_helper_symbol_name", ")", ";", "if", "(", "flag_delayed_branch", ")", "fprintf", "(", "asm_out_file", ",", "\"\\tjmp\\t%%o7+8\\n\\t add\\t%%o7, %s, %s\\n\"", ",", "pic_name", ",", "pic_name", ")", ";", "else", "fprintf", "(", "asm_out_file", ",", "\"\\tadd\\t%%o7, %s, %s\\n\\tjmp\\t%%o7+8\\n\\t nop\\n\"", ",", "pic_name", ",", "pic_name", ")", ";", "pic_helper_emitted_p", "=", "true", ";", "}", "</s>" ]

[ "Emit", "the", "special", "PIC", "helper", "function", "." ]

[ "sparc", "0", "\"\\tjmp\\t%%o7+8\\n\\t add\\t%%o7, %s, %s\\n\"", "\"\\tadd\\t%%o7, %s, %s\\n\\tjmp\\t%%o7+8\\n\\t nop\\n\"" ]

[]

[ "<s>", "memory_access_direction", "determine_access_direction", "(", "rtx_insn", "*", "insn", ")", "{", "int", "post_update_rtx_index", ";", "rtx", "plus_rtx", ";", "rtx", "mem_rtx", ";", "rtx", "offset_rtx", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD_MULTIPLE", ":", "gcc_assert", "(", "parallel_elements", "(", "insn", ")", ">=", "2", ")", ";", "post_update_rtx_index", "=", "find_post_update_rtx", "(", "insn", ")", ";", "if", "(", "post_update_rtx_index", "!=", "-", "1", ")", "plus_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "insn", ",", "post_update_rtx_index", ")", ")", ";", "else", "{", "mem_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "insn", ",", "1", ")", ")", ";", "if", "(", "GET_CODE", "(", "mem_rtx", ")", "==", "UNSPEC", ")", "mem_rtx", "=", "XVECEXP", "(", "mem_rtx", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem_rtx", ")", ")", ";", "plus_rtx", "=", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "}", "break", ";", "case", "TYPE_STORE_MULTIPLE", ":", "gcc_assert", "(", "parallel_elements", "(", "insn", ")", ">=", "2", ")", ";", "post_update_rtx_index", "=", "find_post_update_rtx", "(", "insn", ")", ";", "if", "(", "post_update_rtx_index", "!=", "-", "1", ")", "plus_rtx", "=", "SET_SRC", "(", "parallel_element", "(", "insn", ",", "post_update_rtx_index", ")", ")", ";", "else", "{", "mem_rtx", "=", "SET_DEST", "(", "parallel_element", "(", "insn", ",", "1", ")", ")", ";", "if", "(", "GET_CODE", "(", "mem_rtx", ")", "==", "UNSPEC", ")", "mem_rtx", "=", "XVECEXP", "(", "mem_rtx", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem_rtx", ")", ")", ";", "plus_rtx", "=", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "}", "break", ";", "case", "TYPE_LOAD", ":", "case", "TYPE_STORE", ":", "mem_rtx", "=", "extract_mem_rtx", "(", "insn", ")", ";", "switch", "(", "GET_CODE", "(", "XEXP", "(", "mem_rtx", ",", "0", ")", ")", ")", "{", "case", "POST_INC", ":", "return", "MEM_ACCESS_DIR_POS", ";", "case", "POST_DEC", ":", "return", "MEM_ACCESS_DIR_NEG", ";", "case", "PLUS", ":", "plus_rtx", "=", "XEXP", "(", "mem_rtx", ",", "0", ")", ";", "break", ";", "case", "POST_MODIFY", ":", "plus_rtx", "=", "XEXP", "(", "XEXP", "(", "mem_rtx", ",", "0", ")", ",", "1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "plus_rtx", ")", "==", "PLUS", ")", ";", "offset_rtx", "=", "XEXP", "(", "plus_rtx", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "offset_rtx", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "offset_rtx", ")", "<", "0", ")", "return", "MEM_ACCESS_DIR_NEG", ";", "else", "return", "MEM_ACCESS_DIR_POS", ";", "}", "return", "MEM_ACCESS_DIR_UNKNOWN", ";", "}", "</s>" ]

[ "Determine", "the", "memory", "access", "direction", "of", "a", "load/store", "insn", "." ]

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

[]

[ "<s>", "bool", "PhysicalRegisterInfo", "::", "alias", "(", "RegisterRef", "RA", ",", "RegisterRef", "RB", ")", "const", "{", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "RA", ".", "Reg", ")", ")", ";", "assert", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "RB", ".", "Reg", ")", ")", ";", "MCRegUnitMaskIterator", "UMA", "(", "RA", ".", "Reg", ",", "&", "TRI", ")", ";", "MCRegUnitMaskIterator", "UMB", "(", "RB", ".", "Reg", ",", "&", "TRI", ")", ";", "while", "(", "UMA", ".", "isValid", "(", ")", "&&", "UMB", ".", "isValid", "(", ")", ")", "{", "std", "::", "pair", "<", "uint32_t", ",", "LaneBitmask", ">", "PA", "=", "*", "UMA", ";", "std", "::", "pair", "<", "uint32_t", ",", "LaneBitmask", ">", "PB", "=", "*", "UMB", ";", "if", "(", "PA", ".", "first", "==", "PB", ".", "first", ")", "{", "if", "(", "PA", ".", "second", ".", "none", "(", ")", "||", "PB", ".", "second", ".", "none", "(", ")", ")", "return", "true", ";", "LaneBitmask", "LA", "=", "PA", ".", "second", "&", "RA", ".", "Mask", ";", "LaneBitmask", "LB", "=", "PB", ".", "second", "&", "RB", ".", "Mask", ";", "if", "(", "LA", ".", "any", "(", ")", "&&", "LB", ".", "any", "(", ")", ")", "{", "unsigned", "Root", "=", "*", "MCRegUnitRootIterator", "(", "PA", ".", "first", ",", "&", "TRI", ")", ";", "uint32_t", "SubA", "=", "TRI", ".", "getSubRegIndex", "(", "RA", ".", "Reg", ",", "Root", ")", ";", "uint32_t", "SubB", "=", "TRI", ".", "getSubRegIndex", "(", "RB", ".", "Reg", ",", "Root", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfos", "[", "Root", "]", ".", "RegClass", ";", "LaneBitmask", "RCMask", "=", "RC", "!=", "nullptr", "?", "RC", "->", "LaneMask", ":", "LaneBitmask", "(", "0x1", ")", ";", "LaneBitmask", "MaskA", "=", "TRI", ".", "reverseComposeSubRegIndexLaneMask", "(", "SubA", ",", "LA", ")", ";", "LaneBitmask", "MaskB", "=", "TRI", ".", "reverseComposeSubRegIndexLaneMask", "(", "SubB", ",", "LB", ")", ";", "if", "(", "(", "MaskA", "&", "MaskB", "&", "RCMask", ")", ".", "any", "(", ")", ")", "return", "true", ";", "}", "++", "UMA", ";", "++", "UMB", ";", "continue", ";", "}", "if", "(", "PA", ".", "first", "<", "PB", ".", "first", ")", "++", "UMA", ";", "else", "if", "(", "PB", ".", "first", "<", "PA", ".", "first", ")", "++", "UMB", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "alias", "-", "If", "one", "of", "the", "pointers", "is", "to", "a", "global", "that", "we", "are", "tracking", ",", "and", "the", "other", "is", "some", "random", "pointer", ",", "we", "know", "there", "can", "not", "be", "an", "alias", ",", "because", "the", "address", "of", "the", "global", "is", "n't", "taken", "." ]

[ "Hexagon", "0x1" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getPartialRegUpdateClearance", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "PartialUpdateClearance", "=", "Subtarget", ".", "getPartialUpdateClearance", "(", ")", ";", "if", "(", "!", "PartialUpdateClearance", ")", "return", "0", ";", "assert", "(", "TRI", "&&", "\"Need TRI instance\"", ")", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNum", ")", ";", "if", "(", "MO", ".", "readsReg", "(", ")", ")", "return", "0", ";", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "int", "UseOp", "=", "-", "1", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "FCONSTS", ":", "case", "ARM", "::", "VMOVSR", ":", "case", "ARM", "::", "VMOVv8i8", ":", "case", "ARM", "::", "VMOVv4i16", ":", "case", "ARM", "::", "VMOVv2i32", ":", "case", "ARM", "::", "VMOVv2f32", ":", "case", "ARM", "::", "VMOVv1i64", ":", "UseOp", "=", "MI", ".", "findRegisterUseOperandIdx", "(", "Reg", ",", "false", ",", "TRI", ")", ";", "break", ";", "case", "ARM", "::", "VLD1LNd32", ":", "UseOp", "=", "3", ";", "break", ";", "default", ":", "return", "0", ";", "}", "if", "(", "UseOp", "!=", "-", "1", "&&", "MI", ".", "getOperand", "(", "UseOp", ")", ".", "readsReg", "(", ")", ")", "return", "0", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Reg", ")", ")", "{", "if", "(", "!", "MO", ".", "getSubReg", "(", ")", "||", "MI", ".", "readsVirtualRegister", "(", "Reg", ")", ")", "return", "0", ";", "}", "else", "if", "(", "ARM", "::", "SPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "DReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "Reg", ",", "ARM", "::", "ssub_0", ",", "&", "ARM", "::", "DPRRegClass", ")", ";", "if", "(", "!", "DReg", "||", "!", "MI", ".", "definesRegister", "(", "DReg", ",", "TRI", ")", ")", "return", "0", ";", "}", "return", "PartialUpdateClearance", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "a", "partial", "register", "update", "." ]

[ "ARM", "ARM", "0", "\"Need TRI instance\"", "0", "1", "ARM::VLDRS", "ARM::FCONSTS", "ARM::VMOVSR", "ARM::VMOVv8i8", "ARM::VMOVv4i16", "ARM::VMOVv2i32", "ARM::VMOVv2f32", "ARM::VMOVv1i64", "ARM::VLD1LNd32", "3", "0", "1", "0", "0", "ARM::SPRRegClass", "ARM::ssub_0", "ARM::DPRRegClass", "0" ]

[]

[ "<s>", "BitVector", "XCoreRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "XCoreFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "CP", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "DP", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "XCore", "::", "LR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "XCore", "::", "R10", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore::CP", "XCore::DP", "XCore::SP", "XCore::LR", "XCore::R10" ]

[]

[ "<s>", "bool", "MCS51AsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "llvm_unreachable", "(", "\"This branch is not implemented yet\"", ")", ";", "}", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "(", "void", ")", "MO", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"Unexpected inline asm memory operand\"", ")", ";", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "MCS51", "::", "R31R30", ")", "{", "O", "<<", "\"Z\"", ";", "}", "else", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "==", "MCS51", "::", "R29R28", "&&", "\"Wrong register class for memory operand.\"", ")", ";", "O", "<<", "\"Y\"", ";", "}", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "if", "(", "NumOpRegs", "==", "2", ")", "{", "O", "<<", "'+'", "<<", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "MCS51", "MCS51", "0", "\"This branch is not implemented yet\"", "\"Unexpected inline asm memory operand\"", "MCS51::R31R30", "\"Z\"", "MCS51::R29R28", "\"Wrong register class for memory operand.\"", "\"Y\"", "1", "2", "1" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "0", "MSP430::POP16r" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::AND", "ISD::BRCOND", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::FP_TO_SINT", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::OR", "ISD::SELECT", "ISD::SETCC" ]

[]

[ "<s>", "static", "unsigned", "int", "constant_pool_broadcast", "(", "void", ")", "{", "timevar_push", "(", "TV_MACH_DEP", ")", ";", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", ")", "replace_constant_pool_with_broadcast", "(", "insn", ")", ";", "}", "timevar_pop", "(", "TV_MACH_DEP", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "For", "const", "vector", "having", "one", "duplicated", "value", ",", "there", "'s", "no", "need", "to", "put", "whole", "vector", "in", "the", "constant", "pool", "when", "target", "supports", "embedded", "broadcast", "." ]

[ "i386", "0" ]

[]

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

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "static", "rtx", "sparc_function_value_1", "(", "const_tree", "type", ",", "machine_mode", "mode", ",", "bool", "outgoing", ")", "{", "int", "regbase", "=", "(", "outgoing", "?", "SPARC_INCOMING_INT_ARG_FIRST", ":", "SPARC_OUTGOING_INT_ARG_FIRST", ")", ";", "enum", "mode_class", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "int", "regno", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "(", "TARGET_ARCH32", "&&", "size", "<=", "8", ")", "||", "(", "TARGET_ARCH64", "&&", "size", "<=", "32", ")", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_vector_value", "(", "size", ",", "SPARC_FP_ARG_FIRST", ")", ";", "mclass", "=", "MODE_FLOAT", ";", "}", "if", "(", "TARGET_ARCH64", "&&", "type", ")", "{", "if", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "32", ")", ";", "return", "function_arg_record_value", "(", "type", ",", "mode", ",", "0", ",", "1", ",", "regbase", ")", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "32", ")", ";", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "0", ",", "regbase", ")", ";", "}", "else", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", ";", "else", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "gcc_assert", "(", "size", "<=", "32", ")", ";", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "else_blk", "(", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "function_arg_union_value", "(", "size", ",", "mode", ",", "0", ",", "regbase", ")", ";", "else", "mclass", "=", "MODE_INT", ";", "}", "else", "if", "(", "mclass", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "mode", "=", "word_mode", ";", "}", "else", "if", "(", "TARGET_ARCH32", "&&", "!", "(", "type", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "&&", "mclass", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<", "UNITS_PER_WORD", ")", "mode", "=", "word_mode", ";", "if", "(", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "TARGET_FPU", ")", "regno", "=", "SPARC_FP_ARG_FIRST", ";", "else", "regno", "=", "regbase", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Handle", "TARGET_FUNCTION_VALUE", ",", "and", "TARGET_LIBCALL_VALUE", "target", "hook", ".", "For", "v9", ",", "function", "return", "values", "are", "subject", "to", "the", "same", "rules", "as", "arguments", ",", "except", "that", "up", "to", "32", "bytes", "may", "be", "returned", "in", "registers", "." ]

[ "sparc", "8", "32", "32", "0", "1", "32", "0", "32", "0", "0" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "assert", "(", "(", "Size", "==", "1", "||", "Size", "==", "2", "||", "Size", "==", "4", ")", "&&", "\"Unsupported size\"", ")", ";", "if", "(", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "SExt", "||", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExt", ")", "{", "Size", "=", "4", ";", "assert", "(", "MRI", ".", "getType", "(", "ValVReg", ")", ".", "isScalar", "(", ")", "&&", "\"Only scalars supported atm\"", ")", ";", "MRI", ".", "setType", "(", "ValVReg", ",", "LLT", "::", "scalar", "(", "32", ")", ")", ";", "}", "auto", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "0", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "ARM", "1", "2", "4", "\"Unsupported size\"", "4", "\"Only scalars supported atm\"", "32", "0" ]

[]

[ "<s>", "bool", "Thumb1FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPUSH", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", "&&", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ")", "isKill", "=", "false", ";", "}", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "MIB", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tPUSH", "0", "1", "ARM::LR" ]

[]

[ "<s>", "bool", "AVRAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "Loc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "return", "emit", "(", "Inst", ",", "Loc", ",", "Out", ")", ";", "case", "Match_MissingFeature", ":", "return", "missingFeature", "(", "Loc", ",", "ErrorInfo", ")", ";", "case", "Match_InvalidOperand", ":", "return", "invalidOperand", "(", "Loc", ",", "Operands", ",", "ErrorInfo", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "Loc", ",", "\"invalid instruction\"", ")", ";", "case", "Match_InvalidRegisterOnTiny", ":", "return", "Error", "(", "Loc", ",", "\"invalid register on avrtiny\"", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "AVR", "AVR", "\"invalid instruction\"", "\"invalid register on avrtiny\"" ]

[]

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

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

[ "aarch64" ]

[]

[ "<s>", "unsigned", "VEInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"VE branch conditions should have three component!\"", ")", ";", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "VE", "::", "BRCFLa_t", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", "[", "0", "]", ".", "isImm", "(", ")", "&&", "Cond", "[", "2", "]", ".", "isReg", "(", ")", "&&", "\"not implemented\"", ")", ";", "unsigned", "opc", "[", "2", "]", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "Cond", "[", "2", "]", ".", "getReg", "(", ")", ";", "if", "(", "IsIntegerCC", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "if", "(", "TRI", "->", "getRegSizeInBits", "(", "Reg", ",", "MRI", ")", "==", "32", ")", "{", "opc", "[", "0", "]", "=", "VE", "::", "BRCFWir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BRCFWrr", ";", "}", "else", "{", "opc", "[", "0", "]", "=", "VE", "::", "BRCFLir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BRCFLrr", ";", "}", "}", "else", "{", "if", "(", "TRI", "->", "getRegSizeInBits", "(", "Reg", ",", "MRI", ")", "==", "32", ")", "{", "opc", "[", "0", "]", "=", "VE", "::", "BRCFSir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BRCFSrr", ";", "}", "else", "{", "opc", "[", "0", "]", "=", "VE", "::", "BRCFDir", ";", "opc", "[", "1", "]", "=", "VE", "::", "BRCFDrr", ";", "}", "}", "if", "(", "Cond", "[", "1", "]", ".", "isImm", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "opc", "[", "0", "]", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "opc", "[", "1", "]", ")", ")", ".", "add", "(", "Cond", "[", "0", "]", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ".", "add", "(", "Cond", "[", "2", "]", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "VE", "::", "BRCFLa_t", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "VE", "VE", "\"insertBranch must not be told to insert a fallthrough\"", "3", "0", "\"VE branch conditions should have three component!\"", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "VE::BRCFLa_t", "1", "0", "2", "\"not implemented\"", "2", "2", "0", "32", "0", "VE::BRCFWir", "1", "VE::BRCFWrr", "0", "VE::BRCFLir", "1", "VE::BRCFLrr", "32", "0", "VE::BRCFSir", "1", "VE::BRCFSrr", "0", "VE::BRCFDir", "1", "VE::BRCFDrr", "1", "0", "0", "1", "2", "1", "0", "1", "2", "1", "VE::BRCFLa_t", "2" ]

[]

[ "<s>", "int", "unicosmk_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "int", "fixed_size", ";", "fixed_size", "=", "alpha_sa_size", "(", ")", ";", "if", "(", "fixed_size", "!=", "0", ")", "fixed_size", "+=", "48", ";", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "-", "fixed_size", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "0", ";", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "ALPHA_ROUND", "(", "current_function_outgoing_args_size", ")", "+", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", ")", ")", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "ALPHA_ROUND", "(", "fixed_size", ")", "+", "ALPHA_ROUND", "(", "get_frame_size", "(", ")", "+", "current_function_outgoing_args_size", ")", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "alpha", "0", "48", "0" ]

[]

[ "<s>", "MCSymbol", "*", "TeeRISCMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "TeeRISC", "TeeRISC", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "bool", "PPCCallLowering", "::", "lowerCall", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "CallLoweringInfo", "&", "Info", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "given", "call", "instruction", ",", "including", "argument", "and", "return", "value", "marshalling", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "static", "rtx", "tilegx_text_label_symbol", "(", "void", ")", "{", "return", "cfun", "->", "machine", "->", "text_label_symbol", ";", "}", "</s>" ]

[ "Return", "the", "rtx", "containing", "SYMBOL_REF", "to", "the", "text", "label", "." ]

[ "tilegx" ]

[]

[ "<s>", "bool", "riscv_gimple_fold_builtin", "(", "gimple_stmt_iterator", "*", "gsi", ")", "{", "gcall", "*", "stmt", "=", "as_a", "<", "gcall", "*", ">", "(", "gsi_stmt", "(", "*", "gsi", ")", ")", ";", "tree", "fndecl", "=", "gimple_call_fndecl", "(", "stmt", ")", ";", "unsigned", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "unsigned", "int", "subcode", "=", "code", ">>", "RISCV_BUILTIN_SHIFT", ";", "gimple", "*", "new_stmt", "=", "NULL", ";", "switch", "(", "code", "&", "RISCV_BUILTIN_CLASS", ")", "{", "case", "RISCV_BUILTIN_GENERAL", ":", "new_stmt", "=", "NULL", ";", "break", ";", "case", "RISCV_BUILTIN_VECTOR", ":", "new_stmt", "=", "riscv_vector", "::", "gimple_fold_builtin", "(", "subcode", ",", "gsi", ",", "stmt", ")", ";", "break", ";", "}", "if", "(", "!", "new_stmt", ")", "return", "false", ";", "gsi_replace", "(", "gsi", ",", "new_stmt", ",", "false", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_GIMPLE_FOLD_BUILTIN", "." ]

[ "riscv", "riscv_vector::gimple_fold_builtin" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitImplicitDef", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "Register", "RegNo", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "RegNo", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "Twine", "(", "\"implicit-def: \"", ")", "+", "getVirtualRegisterName", "(", "RegNo", ")", ")", ";", "}", "else", "{", "const", "NVPTXSubtarget", "&", "STI", "=", "MI", "->", "getMF", "(", ")", "->", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ";", "OutStreamer", "->", "AddComment", "(", "Twine", "(", "\"implicit-def: \"", ")", "+", "STI", ".", "getRegisterInfo", "(", ")", "->", "getName", "(", "RegNo", ")", ")", ";", "}", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "customize", "the", "output", "of", "IMPLICIT_DEF", "instructions", "in", "verbose", "mode", "." ]

[ "NVPTX", "NVPTX", "0", "\"implicit-def: \"", "NVPTX", "NVPTX", "\"implicit-def: \"" ]

[]

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

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "MipsSETargetLowering", "::", "getOpndList", "(", "SmallVectorImpl", "<", "SDValue", ">", "&", "Ops", ",", "std", "::", "deque", "<", "std", "::", "pair", "<", "unsigned", ",", "SDValue", ">", ">", "&", "RegsToPass", ",", "bool", "IsPICCall", ",", "bool", "GlobalOrExternal", ",", "bool", "InternalLinkage", ",", "bool", "IsCallReloc", ",", "CallLoweringInfo", "&", "CLI", ",", "SDValue", "Callee", ",", "SDValue", "Chain", ")", "const", "{", "Ops", ".", "push_back", "(", "Callee", ")", ";", "MipsTargetLowering", "::", "getOpndList", "(", "Ops", ",", "RegsToPass", ",", "IsPICCall", ",", "GlobalOrExternal", ",", "InternalLinkage", ",", "IsCallReloc", ",", "CLI", ",", "Callee", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "function", "fills", "Ops", ",", "which", "is", "the", "list", "of", "operands", "that", "will", "later", "be", "used", "when", "a", "function", "call", "node", "is", "created", "." ]

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

[]

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

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "bool", "csky_can_use_ldstm", "(", "int", "mask", ",", "int", "*", "br", ",", "int", "*", "er", ")", "{", "int", "regno", ";", "int", "begin_reg", "=", "0", ",", "end_reg", "=", "0", ";", "int", "count", "=", "0", ";", "if", "(", "!", "TARGET_MULTIPLE_STLD", ")", "return", "false", ";", "if", "(", "mask", "&", "0xf", ")", "return", "false", ";", "for", "(", "regno", "=", "4", ";", "regno", "<=", "11", ";", "regno", "++", ")", "{", "if", "(", "mask", "&", "1", "<<", "regno", ")", "{", "if", "(", "!", "begin_reg", ")", "begin_reg", "=", "regno", ";", "end_reg", "=", "regno", ";", "count", "++", ";", "}", "else", "if", "(", "begin_reg", ")", "break", ";", "}", "if", "(", "count", ">=", "CSKY_MIN_MULTIPLE_STLD", "&&", "count", "<=", "CSKY_MAX_MULTIPLE_STLD", ")", "{", "if", "(", "br", ")", "*", "br", "=", "begin_reg", ";", "if", "(", "er", ")", "*", "er", "=", "end_reg", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "store/load", "multiple", "instructions", "can", "be", "used", "to", "save/restore", "at", "least", "some", "of", "the", "registers", "indicated", "by", "MASK", ".", "Unlike", "the", "push/pop", "case", ",", "this", "does", "handle", "partial", "ranges", ".", "Set", "*", "BR", "and", "*", "ER", "to", "the", "beginning", "and", "end", "(", "respectively", ")", "of", "the", "register", "range", "that", "can", "be", "handled", "." ]

[ "csky", "0", "0", "0", "0xf", "4", "11", "1" ]

[]

[ "<s>", "static", "void", "riscv_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gp_saved", ";", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "riscv_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "mode", ",", "type", ",", "1", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_gprs", ";", "if", "(", "!", "no_rtl", "&&", "gp_saved", ">", "0", ")", "{", "rtx", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "-", "gp_saved", "*", "UNITS_PER_WORD", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "num_gprs", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "==", "0", ")", "cfun", "->", "machine", "->", "varargs_size", "=", "gp_saved", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

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

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

[]

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

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

[ "Sparc" ]

[]

[ "<s>", "static", "rtx", "csky_libcall_value", "(", "machine_mode", "mode", ",", "const_rtx", "libcall", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "FUNCTION_VARG_MODE_P", "(", "mode", ")", ")", "{", "return", "gen_rtx_REG", "(", "mode", ",", "CSKY_FIRST_VFP_REGNUM", ")", ";", "}", "return", "gen_rtx_REG", "(", "mode", ",", "CSKY_FIRST_RET_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_LIBCALL_VALUE", "." ]

[ "csky" ]

[]

[ "<s>", "static", "rtx", "F", "(", "rtx", "x", ")", "{", "RTX_FRAME_RELATED_P", "(", "x", ")", "=", "1", ";", "return", "x", ";", "}", "</s>" ]

[ "We", "use", "this", "to", "wrap", "all", "emitted", "insns", "in", "the", "prologue", ",", "so", "they", "get", "the", "``", "frame-related", "''", "(", "/f", ")", "flag", "set", "." ]

[ "rl78", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"R600 Control Flow Finalizer Pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Control Flow Finalizer Pass\"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "DominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "DominatorTree", ">", "(", ")", ";", "RegionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "Subtarget", ".", "isAIXABI", "(", ")", ")", "return", "LowerFormalArguments_AIX", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "if", "(", "Subtarget", ".", "is64BitELFABI", "(", ")", ")", "return", "LowerFormalArguments_64SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "if", "(", "Subtarget", ".", "is32BitELFABI", "(", ")", ")", "return", "LowerFormalArguments_32SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::InputArg" ]

[]

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "TRI", "=", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "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", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "I2", ",", "MI", ",", "DoInsertAtI1", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "MSP430FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "const", "MSP430InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MSP430InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "MFI", "->", "setOffsetAdjustment", "(", "-", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "MSP430", "::", "FPW", ",", "RegState", "::", "Kill", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "MOV16rr", ")", ",", "MSP430", "::", "FPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "std", "::", "next", "(", "MF", ".", "begin", "(", ")", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "I", "->", "addLiveIn", "(", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "PUSH16r", ")", ")", "++", "MBBI", ";", "if", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", ")", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "SUB16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "0", "2", "MSP430", "MSP430::PUSH16r", "MSP430::FPW", "MSP430::MOV16rr", "MSP430::FPW", "MSP430::SPW", "MSP430::FPW", "MSP430", "MSP430::PUSH16r", "MSP430::SUB16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "const", "MCExpr", "*", "AArch64TargetStreamer", "::", "addConstantPoolEntry", "(", "const", "MCExpr", "*", "Expr", ",", "unsigned", "Size", ")", "{", "return", "ConstantPools", "->", "addEntry", "(", "Streamer", ",", "Expr", ",", "Size", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "entry", "to", "the", "constant", "pool", "for", "the", "current", "section", "and", "return", "an", "MCExpr", "that", "can", "be", "used", "to", "refer", "to", "the", "constant", "pool", "location", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "OR1K" ]

[]

[ "<s>", "rtx", "expand", "(", "function_expander", "&", "e", ")", "const", "override", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "e", ".", "target", ")", ";", "rtx", "vlenb", "=", "gen_int_mode", "(", "BYTES_PER_RISCV_VECTOR", ",", "mode", ")", ";", "emit_move_insn", "(", "e", ".", "target", ",", "vlenb", ")", ";", "return", "e", ".", "target", ";", "}", "</s>" ]

[ "Expand", "the", "call", "and", "return", "its", "lhs", "." ]

[ "riscv" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "XNCMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "EVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i8", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "XNCM", "::", "GR8RegisterClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "XNCM", "::", "GR16RegisterClass", ")", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "1", "0", "MVT::i8", "0U", "XNCM::GR8RegisterClass", "0U", "XNCM::GR16RegisterClass" ]

[]

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

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

[ "WebAssembly", "WebAssembly" ]

[]

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

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

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

[]

[ "<s>", "MachineInstrBuilder", "SIInstrInfo", "::", "buildIndirectWrite", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ")", "const", "{", "const", "DebugLoc", "&", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "unsigned", "IndirectBaseReg", "=", "AMDGPU", "::", "VReg_32RegClass", ".", "getRegister", "(", "getIndirectIndexBegin", "(", "*", "MBB", "->", "getParent", "(", ")", ")", ")", ";", "return", "BuildMI", "(", "*", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "SI_INDIRECT_DST_V1", ")", ")", ".", "addReg", "(", "IndirectBaseReg", ",", "RegState", "::", "Define", ")", ".", "addOperand", "(", "I", "->", "getOperand", "(", "0", ")", ")", ".", "addReg", "(", "IndirectBaseReg", ")", ".", "addReg", "(", "OffsetReg", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "ValueReg", ")", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "write", "." ]

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

[]

[ "<s>", "int", "c4x_S_constraint", "(", "rtx", "op", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "MEM", ")", "return", "0", ";", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "1", ";", "case", "PRE_MODIFY", ":", "case", "POST_MODIFY", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "(", "GET_CODE", "(", "op1", ")", "!=", "PLUS", "&&", "GET_CODE", "(", "op1", ")", "!=", "MINUS", ")", "||", "(", "op0", "!=", "XEXP", "(", "op1", ",", "0", ")", ")", ")", "return", "0", ";", "op0", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "op1", "=", "XEXP", "(", "op1", ",", "1", ")", ";", "return", "REG_P", "(", "op0", ")", "&&", "REG_P", "(", "op1", ")", ";", "}", "break", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "return", "0", ";", "if", "(", "REG_P", "(", "op1", ")", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "op1", ")", "!=", "CONST_INT", ")", "return", "0", ";", "if", "(", "mode", "==", "HImode", "||", "mode", "==", "HFmode", ")", "return", "IS_DISP1_OFF_CONST", "(", "INTVAL", "(", "op1", ")", ")", ";", "return", "IS_DISP1_CONST", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "break", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "ARx", "+", "1-bit", "unsigned", "const", "or", "IRn", "*", "ARx", ",", "*", "+ARx", "(", "1", ")", ",", "*", "-ARx", "(", "1", ")", ",", "*", "+ARx", "(", "IRn", ")", ",", "*", "-Arx", "(", "IRn", ")", "We", "do", "n't", "include", "the", "pre/post", "inc/dec", "forms", "here", "since", "they", "are", "handled", "by", "the", "<", ">", "constraints", "." ]

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

[]

[ "<s>", "virtual", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "0", ";", "}", "</s>" ]

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

[ "Sparc", "0" ]

[]

[ "<s>", "unsigned", "M68kAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "&", "Op", ",", "unsigned", "Kind", ")", "{", "M68kOperand", "&", "Operand", "=", "(", "M68kOperand", "&", ")", "Op", ";", "switch", "(", "Kind", ")", "{", "case", "MCK_XR16", ":", "case", "MCK_SPILL", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "checkRegisterClass", "(", "Operand", ".", "getReg", "(", ")", ",", "true", ",", "true", ",", "true", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "case", "MCK_AR16", ":", "case", "MCK_AR32", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "checkRegisterClass", "(", "Operand", ".", "getReg", "(", ")", ",", "false", ",", "true", ",", "true", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "case", "MCK_AR32_NOSP", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "checkRegisterClass", "(", "Operand", ".", "getReg", "(", ")", ",", "false", ",", "true", ",", "false", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "case", "MCK_DR8", ":", "case", "MCK_DR16", ":", "case", "MCK_DR32", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "checkRegisterClass", "(", "Operand", ".", "getReg", "(", ")", ",", "true", ",", "false", ",", "false", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "case", "MCK_AR16_TC", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "(", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "A0", ")", "||", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "A1", ")", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "case", "MCK_DR16_TC", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "(", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "D0", ")", "||", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "D1", ")", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "case", "MCK_XR16_TC", ":", "if", "(", "Operand", ".", "isReg", "(", ")", "&&", "(", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "D0", ")", "||", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "D1", ")", "||", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "A0", ")", "||", "(", "Operand", ".", "getReg", "(", ")", "==", "M68k", "::", "A1", ")", ")", ")", "{", "return", "Match_Success", ";", "}", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "M68k", "M68k", "M68k", "M68k", "M68k::A0", "M68k::A1", "M68k::D0", "M68k::D1", "M68k::D0", "M68k::D1", "M68k::A0", "M68k::A1" ]

[]

[ "<s>", "static", "bool", "addr_generation_dependency_p", "(", "rtx", "dep_rtx", ",", "rtx", "insn", ")", "{", "rtx", "target", ",", "pat", ";", "if", "(", "GET_CODE", "(", "dep_rtx", ")", "==", "INSN", ")", "dep_rtx", "=", "PATTERN", "(", "dep_rtx", ")", ";", "if", "(", "GET_CODE", "(", "dep_rtx", ")", "==", "SET", ")", "{", "target", "=", "SET_DEST", "(", "dep_rtx", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "==", "STRICT_LOW_PART", ")", "target", "=", "XEXP", "(", "target", ",", "0", ")", ";", "while", "(", "GET_CODE", "(", "target", ")", "==", "SUBREG", ")", "target", "=", "SUBREG_REG", "(", "target", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "==", "REG", ")", "{", "int", "regno", "=", "REGNO", "(", "target", ")", ";", "if", "(", "s390_safe_attr_type", "(", "insn", ")", "==", "TYPE_LA", ")", "{", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "gcc_assert", "(", "XVECLEN", "(", "pat", ",", "0", ")", "==", "2", ")", ";", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", ";", "return", "refers_to_regno_p", "(", "regno", ",", "regno", "+", "1", ",", "SET_SRC", "(", "pat", ")", ",", "0", ")", ";", "}", "else", "if", "(", "get_attr_atype", "(", "insn", ")", "==", "ATYPE_AGEN", ")", "return", "reg_used_in_mem_p", "(", "regno", ",", "PATTERN", "(", "insn", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "expression", "DEP_RTX", "sets", "an", "address", "register", "used", "by", "instruction", "INSN", "to", "address", "memory", "." ]

[ "s390", "0", "0", "2", "0", "0", "1", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "ARMBaseInstrInfo", "::", "decomposeMachineOperandsTargetFlags", "(", "unsigned", "TF", ")", "const", "{", "const", "unsigned", "Mask", "=", "ARMII", "::", "MO_OPTION_MASK", ";", "return", "std", "::", "make_pair", "(", "TF", "&", "Mask", ",", "TF", "&", "~", "Mask", ")", ";", "}", "</s>" ]

[ "Decompose", "the", "machine", "operand", "'s", "target", "flags", "into", "two", "values", "-", "the", "direct", "target", "flag", "value", "and", "any", "of", "bit", "flags", "that", "are", "applied", "." ]

[ "ARM", "ARM", "ARMII::MO_OPTION_MASK" ]

[]

[ "<s>", "static", "void", "arm_print_asm_arch_directives", "(", ")", "{", "const", "arch_option", "*", "arch", "=", "arm_parse_arch_option_name", "(", "all_architectures", ",", "\"-march\"", ",", "arm_active_target", ".", "arch_name", ")", ";", "auto_sbitmap", "opt_bits", "(", "isa_num_bits", ")", ";", "gcc_assert", "(", "arch", ")", ";", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arch %s\\n\"", ",", "arm_active_target", ".", "arch_name", ")", ";", "arm_last_printed_arch_string", "=", "arm_active_target", ".", "arch_name", ";", "if", "(", "!", "arch", "->", "common", ".", "extensions", ")", "return", ";", "for", "(", "const", "struct", "cpu_arch_extension", "*", "opt", "=", "arch", "->", "common", ".", "extensions", ";", "opt", "->", "name", "!=", "NULL", ";", "opt", "++", ")", "{", "if", "(", "!", "opt", "->", "remove", ")", "{", "arm_initialize_isa", "(", "opt_bits", ",", "opt", "->", "isa_bits", ")", ";", "if", "(", "bitmap_subset_p", "(", "opt_bits", ",", "arm_active_target", ".", "isa", ")", "&&", "!", "bitmap_subset_p", "(", "opt_bits", ",", "isa_all_fpubits", ")", ")", "asm_fprintf", "(", "asm_out_file", ",", "\"\\t.arch_extension %s\\n\"", ",", "opt", "->", "name", ")", ";", "}", "}", "}", "</s>" ]

[ "Print", ".arch", "and", ".arch_extension", "directives", "corresponding", "to", "the", "current", "architecture", "configuration", "." ]

[ "arm", "\"-march\"", "\"\\t.arch %s\\n\"", "\"\\t.arch_extension %s\\n\"" ]

[]

[ "<s>", "virtual", "const", "TargetRegisterClass", "*", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "assert", "(", "!", "\"Unimplemented\"", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "AMDGPU", "\"Unimplemented\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "P2RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "CSR_RegMask", "[", "0", "]", "<<", "\"\\n\"", ")", ";", "return", "CSR_RegMask", ";", "}", "</s>" ]

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

[ "P2", "P2", "0", "\"\\n\"" ]

[]

[ "<s>", "bool", "PPCAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'y'", ":", "{", "const", "char", "*", "RegName", "=", "\"r0\"", ";", "if", "(", "!", "Subtarget", "->", "isDarwin", "(", ")", ")", "RegName", "=", "PPCRegisterInfo", "::", "stripRegisterPrefix", "(", "RegName", ")", ";", "O", "<<", "RegName", "<<", "\", \"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'U'", ":", "case", "'X'", ":", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";", "}", "}", "}", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "O", "<<", "\"0(\"", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "O", "<<", "\")\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "PowerPC", "PPC", "0", "1", "0", "0", "\"r0\"", "PPC", "\", \"", "\"0(\"", "\")\"" ]

[]

[ "<s>", "SDValue", "AArch64TargetLowering", "::", "getTargetNode", "(", "ConstantPoolSDNode", "*", "N", ",", "EVT", "Ty", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Flag", ")", "const", "{", "return", "DAG", ".", "getTargetConstantPool", "(", "N", "->", "getConstVal", "(", ")", ",", "Ty", ",", "N", "->", "getAlignment", "(", ")", ",", "N", "->", "getOffset", "(", ")", ",", "Flag", ")", ";", "}", "</s>" ]

[ "Retrieve", "the", "target", "node", "this", "edge", "connects", "to", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

[ "<s>", "void", "WebAssemblyTargetAsmStreamer", "::", "emitGlobalType", "(", "const", "MCSymbolWasm", "*", "Sym", ")", "{", "assert", "(", "Sym", "->", "isGlobal", "(", ")", ")", ";", "OS", "<<", "\"\\t.globaltype\\t\"", "<<", "Sym", "->", "getName", "(", ")", "<<", "\", \"", "<<", "WebAssembly", "::", "TypeToString", "(", "static_cast", "<", "wasm", "::", "ValType", ">", "(", "Sym", "->", "getGlobalType", "(", ")", ".", "Type", ")", ")", "<<", "'\\n'", ";", "}", "</s>" ]

[ ".globaltype" ]

[ "WebAssembly", "WebAssembly", "\"\\t.globaltype\\t\"", "\", \"", "WebAssembly::TypeToString", "wasm::ValType" ]

[]

[ "<s>", "bool", "Inserter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "Cpu0FunctionInfo", "*", "Cpu0FI", "=", "F", ".", "getInfo", "<", "Cpu0FunctionInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "*", "STI", "=", "TM", ".", "getSubtargetImpl", "(", "*", "(", "F", ".", "getFunction", "(", ")", ")", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "if", "(", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "||", "(", "!", "Cpu0FI", "->", "globalBaseRegFixed", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "int", "FI", "=", "Cpu0FI", "->", "getGPFI", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "F", ".", "begin", "(", ")", ",", "MFE", "=", "F", ".", "end", "(", ")", ";", "MFI", "!=", "MFE", ";", "++", "MFI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MFI", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MFI", "->", "begin", "(", ")", ";", "if", "(", "MBB", ".", "isEHPad", "(", ")", ")", "{", "for", "(", ";", "I", "->", "getOpcode", "(", ")", "!=", "TargetOpcode", "::", "EH_LABEL", ";", "++", "I", ")", ";", "++", "I", ";", "DebugLoc", "dl", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", "->", "get", "(", "Cpu0", "::", "LD", ")", ",", "Cpu0", "::", "GP", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "Changed", "=", "true", ";", "}", "while", "(", "I", "!=", "MFI", "->", "end", "(", ")", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Cpu0", "::", "JALR", ")", "{", "++", "I", ";", "continue", ";", "}", "DebugLoc", "dl", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "I", ",", "dl", ",", "TII", "->", "get", "(", "Cpu0", "::", "LD", ")", ",", "Cpu0", "::", "GP", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "Changed", "=", "true", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0", "Cpu0::LD", "Cpu0::GP", "0", "Cpu0::JALR", "Cpu0::LD", "Cpu0::GP", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_mult_zero_zero_cost", "(", "struct", "mips_sim", "*", "state", ",", "bool", "setting", ")", "{", "mips_tuning_info", ".", "fast_mult_zero_zero_p", "=", "setting", ";", "start_sequence", "(", ")", ";", "machine_mode", "dword_mode", "=", "TARGET_64BIT", "?", "TImode", ":", "DImode", ";", "rtx", "hilo", "=", "gen_rtx_REG", "(", "dword_mode", ",", "MD_REG_FIRST", ")", ";", "mips_emit_move_or_split", "(", "hilo", ",", "const0_rtx", ",", "SPLIT_FOR_SPEED", ")", ";", "if", "(", "dword_mode", "==", "DImode", "&&", "HAVE_maddsidi4", ")", "{", "rtx", "gpr", "=", "gen_rtx_REG", "(", "SImode", ",", "GP_REG_FIRST", "+", "4", ")", ";", "emit_insn", "(", "gen_maddsidi4", "(", "hilo", ",", "gpr", ",", "gpr", ",", "hilo", ")", ")", ";", "}", "unsigned", "int", "time", "=", "mips_seq_time", "(", "state", ",", "get_insns", "(", ")", ")", ";", "end_sequence", "(", ")", ";", "return", "time", ";", "}", "</s>" ]

[ "Return", "the", "execution-time", "cost", "of", "mips_tuning_info.fast_mult_zero_zero_p", "setting", "SETTING", ",", "using", "STATE", "to", "simulate", "instruction", "sequences", "." ]

[ "mips", "4" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "hasUnwantedEffectsWhenEXECEmpty", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "MI", ".", "mayStore", "(", ")", "&&", "isSMRD", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SENDMSG", "||", "Opcode", "==", "AMDGPU", "::", "S_SENDMSGHALT", "||", "isEXP", "(", "Opcode", ")", "||", "Opcode", "==", "AMDGPU", "::", "DS_ORDERED_COUNT", "||", "Opcode", "==", "AMDGPU", "::", "S_TRAP", "||", "Opcode", "==", "AMDGPU", "::", "DS_GWS_INIT", "||", "Opcode", "==", "AMDGPU", "::", "DS_GWS_BARRIER", ")", "return", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", "||", "MI", ".", "isInlineAsm", "(", ")", ")", "return", "true", ";", "if", "(", "modifiesModeRegister", "(", "MI", ")", ")", "return", "true", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "V_READFIRSTLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_READLANE_B32", "||", "Opcode", "==", "AMDGPU", "::", "V_WRITELANE_B32", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "we", "must", "prevent", "this", "instruction", "from", "executing", "with", "EXEC", "=", "0", "." ]

[ "AMDGPU", "SI", "AMDGPU::S_SENDMSG", "AMDGPU::S_SENDMSGHALT", "AMDGPU::DS_ORDERED_COUNT", "AMDGPU::S_TRAP", "AMDGPU::DS_GWS_INIT", "AMDGPU::DS_GWS_BARRIER", "AMDGPU::V_READFIRSTLANE_B32", "AMDGPU::V_READLANE_B32", "AMDGPU::V_WRITELANE_B32" ]

[]

[ "<s>", "static", "void", "c6x_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "c6x_arch", "==", "C6X_CPU_C62X", "||", "c6x_arch", "==", "C6X_CPU_C67X", ")", "for", "(", "i", "=", "16", ";", "i", "<", "32", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "fixed_regs", "[", "32", "+", "i", "]", "=", "1", ";", "}", "if", "(", "TARGET_INSNS_64", ")", "{", "SET_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "PREDICATE_A_REGS", "]", ",", "REG_A0", ")", ";", "SET_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "PREDICATE_REGS", "]", ",", "REG_A0", ")", ";", "CLEAR_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "NONPREDICATE_A_REGS", "]", ",", "REG_A0", ")", ";", "CLEAR_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "NONPREDICATE_REGS", "]", ",", "REG_A0", ")", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_CONDITIONAL_REGISTER_USAGE", "hook", "." ]

[ "c6x", "16", "32", "1", "32", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TVM Stack Model\"", ";", "}", "</s>" ]

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

[ "TVM", "\"TVM Stack Model\"" ]

[]

[ "<s>", "Type", "*", "getType", "(", ")", "const", "{", "return", "T", ";", "}", "</s>" ]

[ "Overload", "to", "return", "most", "specific", "vector", "type", "." ]

[ "Patmos" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "insertCopiesSplitCSR", "(", "MachineBasicBlock", "*", "Entry", ",", "const", "SmallVectorImpl", "<", "MachineBasicBlock", "*", ">", "&", "Exits", ")", "const", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getSubtarget", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "const", "MCPhysReg", "*", "IStart", "=", "TRI", "->", "getCalleeSavedRegsViaCopy", "(", "Entry", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "IStart", ")", "return", ";", "const", "TargetInstrInfo", "*", "TII", "=", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "MachineRegisterInfo", "*", "MRI", "=", "&", "Entry", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Entry", "->", "begin", "(", ")", ";", "for", "(", "const", "MCPhysReg", "*", "I", "=", "IStart", ";", "*", "I", ";", "++", "I", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "if", "(", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AMDGPU", "::", "SGPR_64RegClass", ";", "else", "if", "(", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "*", "I", ")", ")", "RC", "=", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class in CSRsViaCopy!\"", ")", ";", "unsigned", "NewVR", "=", "MRI", "->", "createVirtualRegister", "(", "RC", ")", ";", "Entry", "->", "addLiveIn", "(", "*", "I", ")", ";", "BuildMI", "(", "*", "Entry", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVR", ")", ".", "addReg", "(", "*", "I", ")", ";", "for", "(", "auto", "*", "Exit", ":", "Exits", ")", "BuildMI", "(", "*", "Exit", ",", "Exit", "->", "getFirstTerminator", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "*", "I", ")", ".", "addReg", "(", "NewVR", ")", ";", "}", "}", "</s>" ]

[ "Insert", "explicit", "copies", "in", "entry", "and", "exit", "blocks", "." ]

[ "AMDGPU", "SI", "SI", "AMDGPU::SReg_64RegClass", "AMDGPU::SGPR_64RegClass", "AMDGPU::SReg_32RegClass", "AMDGPU::SGPR_32RegClass", "\"Unexpected register class in CSRsViaCopy!\"" ]

[]

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

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

[ "X86" ]

[]

[ "<s>", "HOST_WIDE_INT", "ix86_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "struct", "ix86_frame", "&", "frame", "=", "cfun", "->", "machine", "->", "frame", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "frame", ".", "hard_frame_pointer_offset", ";", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "return", "frame", ".", "hard_frame_pointer_offset", "-", "frame", ".", "frame_pointer_offset", ";", "else", "{", "gcc_assert", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", ")", "return", "frame", ".", "stack_pointer_offset", ";", "gcc_assert", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", ";", "return", "frame", ".", "stack_pointer_offset", "-", "frame", ".", "frame_pointer_offset", ";", "}", "}", "</s>" ]

[ "Return", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "i386" ]

[]

[ "<s>", "unsigned", "MSP430RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "MSP430", "::", "FPW", ":", "MSP430", "::", "SPW", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::SPW" ]

[]

[ "<s>", "static", "bool", "offsettable_ok_by_alignment", "(", "rtx", "op", ",", "HOST_WIDE_INT", "offset", ",", "machine_mode", "mode", ")", "{", "tree", "decl", ";", "unsigned", "HOST_WIDE_INT", "dsize", ",", "dalign", ",", "lsb", ",", "mask", ";", "if", "(", "GET_CODE", "(", "op", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "dsize", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "op", ")", ";", "if", "(", "!", "decl", ")", "{", "if", "(", "dsize", "==", "0", ")", "return", "false", ";", "dalign", "=", "BITS_PER_UNIT", ";", "if", "(", "SYMBOL_REF_HAS_BLOCK_INFO_P", "(", "op", ")", "&&", "SYMBOL_REF_ANCHOR_P", "(", "op", ")", "&&", "SYMBOL_REF_BLOCK", "(", "op", ")", "!=", "NULL", ")", "{", "struct", "object_block", "*", "block", "=", "SYMBOL_REF_BLOCK", "(", "op", ")", ";", "dalign", "=", "block", "->", "alignment", ";", "offset", "+=", "SYMBOL_REF_BLOCK_OFFSET", "(", "op", ")", ";", "}", "else", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "op", ")", ")", "{", "machine_mode", "cmode", "=", "get_pool_mode", "(", "op", ")", ";", "dalign", "=", "GET_MODE_ALIGNMENT", "(", "cmode", ")", ";", "}", "}", "else", "if", "(", "DECL_P", "(", "decl", ")", ")", "{", "dalign", "=", "DECL_ALIGN", "(", "decl", ")", ";", "if", "(", "dsize", "==", "0", ")", "{", "if", "(", "!", "DECL_SIZE_UNIT", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "DECL_SIZE_UNIT", "(", "decl", ")", ")", ")", "return", "false", ";", "dsize", "=", "tree_to_uhwi", "(", "DECL_SIZE_UNIT", "(", "decl", ")", ")", ";", "if", "(", "dsize", ">", "32768", ")", "return", "false", ";", "dalign", "/=", "BITS_PER_UNIT", ";", "if", "(", "dalign", ">", "POWERPC64_TOC_POINTER_ALIGNMENT", ")", "dalign", "=", "POWERPC64_TOC_POINTER_ALIGNMENT", ";", "return", "dalign", ">=", "dsize", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "dalign", "/=", "BITS_PER_UNIT", ";", "if", "(", "dalign", ">", "POWERPC64_TOC_POINTER_ALIGNMENT", ")", "dalign", "=", "POWERPC64_TOC_POINTER_ALIGNMENT", ";", "mask", "=", "dalign", "-", "1", ";", "lsb", "=", "offset", "&", "-", "offset", ";", "mask", "&=", "lsb", "-", "1", ";", "dalign", "=", "mask", "+", "1", ";", "return", "dalign", ">=", "dsize", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "MODE", "sized", "memory", "accesses", "to", "OP", "plus", "OFFSET", "is", "known", "to", "not", "straddle", "a", "32k", "boundary", "." ]

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

[]

[ "<s>", "unsigned", "AArch64RegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "return", "32", "-", "1", "-", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "-", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isX18Reserved", "(", ")", "-", "hasBasePointer", "(", "MF", ")", ";", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "ZPRRegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "case", "AArch64", "::", "ZPR2RegClassID", ":", "case", "AArch64", "::", "ZPR3RegClassID", ":", "case", "AArch64", "::", "ZPR4RegClassID", ":", "return", "32", ";", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "return", "16", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "AArch64", "AArch64", "AArch64", "0", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64allRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR32commonRegClassID", "AArch64::GPR64commonRegClassID", "32", "1", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::ZPRRegClassID", "32", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::ZPR2RegClassID", "AArch64::ZPR3RegClassID", "AArch64::ZPR4RegClassID", "32", "AArch64::FPR128_loRegClassID", "16" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldConvertFpToSat", "(", "unsigned", "Op", ",", "EVT", "FPVT", ",", "EVT", "VT", ")", "const", "{", "if", "(", "FPVT", "==", "MVT", "::", "v8f16", "&&", "!", "Subtarget", "->", "hasFullFP16", "(", ")", ")", "return", "false", ";", "return", "TargetLowering", "::", "shouldConvertFpToSat", "(", "Op", ",", "FPVT", ",", "VT", ")", ";", "}", "</s>" ]

[ "Should", "we", "generate", "fp_to_si_sat", "and", "fp_to_ui_sat", "from", "type", "FPVT", "to", "type", "VT", "from", "min", "(", "max", "(", "fptoi", ")", ")", "saturation", "patterns", "." ]

[ "AArch64", "AArch64", "MVT::v8f16" ]

[]