Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "uint32_t", "BTFStringTable", "::", "addString", "(", "StringRef", "S", ")", "{", "for", "(", "auto", "&", "OffsetM", ":", "OffsetToIdMap", ")", "{", "if", "(", "Table", "[", "OffsetM", ".", "second", "]", "==", "S", ")", "return", "OffsetM", ".", "first", ";", "}", "uint32_t", "Offset", "=", "Size", ";", "OffsetToIdMap", "[", "Offset", "]", "=", "Table", ".", "size", "(", ")", ";", "Table", ".", "push_back", "(", "S", ")", ";", "Size", "+=", "S", ".", "size", "(", ")", "+", "1", ";", "return", "Offset", ";", "}", "</s>" ]

[ "Adds", "path", "Path", "to", "the", "line", "string", "." ]

[ "BPF", "BTFStringTable::addString", "1" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "Mod", "=", "&", "M", ";", "DL", "=", "&", "Mod", "->", "getDataLayout", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "compare_diff_p", "(", "rtx_insn", "*", "insn", ")", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "GT", "||", "cond", "==", "GTU", "||", "cond", "==", "LE", "||", "cond", "==", "LEU", ")", "?", "cond", ":", "0", ";", "}", "</s>" ]

[ "Returns", "nonzero", "if", "the", "next", "insn", "is", "a", "JUMP_INSN", "with", "a", "condition", "that", "needs", "to", "be", "swapped", "(", "GT", ",", "GTU", ",", "LE", ",", "LEU", ")", "." ]

[ "avr", "0" ]

[]

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

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

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "Mips" ]

[]

[ "<s>", "EVT", "ARCompactTargetLowering", "::", "getSetCCResultType", "(", "EVT", "VT", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "ARCompact", "ARC", "MVT::i32" ]

[]

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

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

[ "UPT", "UPT" ]

[]

[ "<s>", "const", "char", "*", "ashlsi3_out", "(", "rtx_insn", "*", "insn", ",", "rtx", "operands", "[", "]", ",", "int", "*", "len", ")", "{", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "int", "k", ";", "int", "*", "t", "=", "len", ";", "if", "(", "!", "len", ")", "len", "=", "&", "k", ";", "switch", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", "{", "default", ":", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "32", ")", "break", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"movw %A0,%C0\"", ")", ";", "*", "len", "=", "4", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "8", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "*", "len", "=", "4", ";", "if", "(", "reg0", ">=", "reg1", ")", "return", "(", "\"mov %D0,%C1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "(", "\"clr %A0\"", "CR_TAB", "\"mov %B0,%A1\"", "CR_TAB", "\"mov %C0,%B1\"", "CR_TAB", "\"mov %D0,%C1\"", ")", ";", "}", "case", "16", ":", "{", "int", "reg0", "=", "true_regnum", "(", "operands", "[", "0", "]", ")", ";", "int", "reg1", "=", "true_regnum", "(", "operands", "[", "1", "]", ")", ";", "if", "(", "reg0", "+", "2", "==", "reg1", ")", "return", "*", "len", "=", "2", ",", "(", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "if", "(", "AVR_HAVE_MOVW", ")", "return", "*", "len", "=", "3", ",", "(", "\"movw %C0,%A1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "else", "return", "*", "len", "=", "4", ",", "(", "\"mov %C0,%A1\"", "CR_TAB", "\"mov %D0,%B1\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "case", "24", ":", "*", "len", "=", "4", ";", "return", "(", "\"mov %D0,%A1\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "case", "31", ":", "*", "len", "=", "6", ";", "return", "(", "\"clr %D0\"", "CR_TAB", "\"lsr %A0\"", "CR_TAB", "\"ror %D0\"", "CR_TAB", "\"clr %C0\"", "CR_TAB", "\"clr %B0\"", "CR_TAB", "\"clr %A0\"", ")", ";", "}", "len", "=", "t", ";", "}", "out_shift_with_cnt", "(", "\"lsl %A0\"", "CR_TAB", "\"rol %B0\"", "CR_TAB", "\"rol %C0\"", "CR_TAB", "\"rol %D0\"", ",", "insn", ",", "operands", ",", "len", ",", "4", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "32bit", "shift", "left", "(", "(", "long", ")", "x", "<", "<", "i", ")" ]

[ "avr", "2", "2", "2", "32", "3", "\"clr %D0\"", "\"clr %C0\"", "\"movw %A0,%C0\"", "4", "\"clr %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "8", "0", "1", "4", "\"mov %D0,%C1\"", "\"mov %C0,%B1\"", "\"mov %B0,%A1\"", "\"clr %A0\"", "\"clr %A0\"", "\"mov %B0,%A1\"", "\"mov %C0,%B1\"", "\"mov %D0,%C1\"", "16", "0", "1", "2", "2", "\"clr %B0\"", "\"clr %A0\"", "3", "\"movw %C0,%A1\"", "\"clr %B0\"", "\"clr %A0\"", "4", "\"mov %C0,%A1\"", "\"mov %D0,%B1\"", "\"clr %B0\"", "\"clr %A0\"", "24", "4", "\"mov %D0,%A1\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "31", "6", "\"clr %D0\"", "\"lsr %A0\"", "\"ror %D0\"", "\"clr %C0\"", "\"clr %B0\"", "\"clr %A0\"", "\"lsl %A0\"", "\"rol %B0\"", "\"rol %C0\"", "\"rol %D0\"", "4", "\"\"" ]

[]

[ "<s>", "const", "ArrayRef", "<", "MCPhysReg", ">", "SICABIInfo", "::", "GetVarArgRegs", "(", ")", "const", "{", "if", "(", "IsO32", "(", ")", ")", "return", "makeArrayRef", "(", "O32IntRegs", ")", ";", "if", "(", "IsS32", "(", ")", ")", "return", "makeArrayRef", "(", "S32IntRegs", ")", ";", "llvm_unreachable", "(", "\"Unhandled ABI\"", ")", ";", "}", "</s>" ]

[ "The", "registers", "to", "use", "for", "the", "variable", "argument", "list", "." ]

[ "SIC", "SIC", "\"Unhandled ABI\"" ]

[]

[ "<s>", "SDValue", "rvexTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "rvexISD", "::", "Ret", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getRegister", "(", "rvex", "::", "LR", ",", "MVT", "::", "i32", ")", ")", ";", "}", "</s>" ]

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

[ "rvex", "rvex", "ISD::OutputArg", "rvexISD::Ret", "MVT::Other", "rvex::LR", "MVT::i32" ]

[]

[ "<s>", "Instruction", "*", "PPCTargetLowering", "::", "emitLeadingFence", "(", "IRBuilder", "<", ">", "&", "Builder", ",", "AtomicOrdering", "Ord", ",", "bool", "IsStore", ",", "bool", "IsLoad", ")", "const", "{", "if", "(", "Ord", "==", "AtomicOrdering", "::", "SequentiallyConsistent", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_sync", ")", ";", "if", "(", "isReleaseOrStronger", "(", "Ord", ")", ")", "return", "callIntrinsic", "(", "Builder", ",", "Intrinsic", "::", "ppc_lwsync", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Custom", "Lower", "{", "." ]

[ "PowerPC", "PPC", "Intrinsic::ppc_sync", "Intrinsic::ppc_lwsync" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameStoreOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "isFrameOperand", "(", "MI", ",", "0", ",", "FrameIndex", ")", ")", "return", "MI", "->", "getOperand", "(", "X86", "::", "AddrNumOperands", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86::AddrNumOperands", "0", "0", "X86::AddrNumOperands", "0" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "Mips", "::", "CPURegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "LW", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "if", "(", "RC", "==", "Mips", "::", "FGR32RegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "LWC1", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "else", "if", "(", "RC", "==", "Mips", "::", "AFGR64RegisterClass", ")", "{", "if", "(", "!", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "isMips1", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "LDC1", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "else", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "unsigned", "*", "SubSet", "=", "TRI", "->", "getSubRegisters", "(", "DestReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "LWC1", ")", ",", "SubSet", "[", "0", "]", ")", ".", "addImm", "(", "0", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Mips", "::", "LWC1", ")", ",", "SubSet", "[", "1", "]", ")", ".", "addImm", "(", "4", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "}", "}", "else", "llvm_unreachable", "(", "\"Register class not handled!\"", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::CPURegsRegisterClass", "Mips::LW", "0", "Mips::FGR32RegisterClass", "Mips::LWC1", "0", "Mips::AFGR64RegisterClass", "Mips", "Mips", "Mips::LDC1", "0", "Mips::LWC1", "0", "0", "Mips::LWC1", "1", "4", "\"Register class not handled!\"" ]

[]

[ "<s>", "static", "void", "m32r_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "*", "cum", "=", "(", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "mode", ",", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "mode", ",", "type", ")", ")", ";", "}", "</s>" ]

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

[ "m32r" ]

[]

[ "<s>", "SDValue", "Z80TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "switch", "(", "N", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "return", "combineExtractSubreg", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "SDValue", "(", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "combineMul", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "combineAnd", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "combineZeroExtend", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "combineTruncate", "(", "N", ",", "DCI", ".", "DAG", ")", ";", "case", "Z80ISD", "::", "SUB", ":", "return", "combineSub", "(", "N", ",", "DCI", ")", ";", "case", "Z80ISD", "::", "SEXT", ":", "return", "combineSExt", "(", "N", ",", "DCI", ".", "DAG", ",", "Subtarget", ")", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "}", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "Z80", "Z80", "ISD::MUL", "ISD::AND", "ISD::ZERO_EXTEND", "ISD::TRUNCATE", "Z80ISD::SUB", "Z80ISD::SEXT" ]

[]

[ "<s>", "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "FrameInfo", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", ")", ";", "MachineBasicBlock", "&", "EntryMBB", "=", "MF", ".", "front", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "EntryMBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg VReg \"", "<<", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "<<", "\" -> WAReg \"", "<<", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "NumStackRegs", "=", "0", ";", "unsigned", "CurReg", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "isVRegStackified", "(", "VReg", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "(", "INT32_MIN", "|", "NumStackRegs", ")", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "INT32_MIN", "|", "NumStackRegs", "++", ")", ";", "continue", ";", "}", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"VReg \"", "<<", "VReg", "<<", "\" -> WAReg \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "setWAReg", "(", "VReg", ",", "CurReg", "++", ")", ";", "}", "}", "bool", "HasFP", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", "->", "hasFP", "(", "MF", ")", ";", "if", "(", "FrameInfo", ".", "getStackSize", "(", ")", ">", "0", "||", "FrameInfo", ".", "adjustsStack", "(", ")", "||", "HasFP", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"PReg SP \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "addPReg", "(", "WebAssembly", "::", "SP32", ",", "CurReg", "++", ")", ";", "}", "if", "(", "HasFP", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"PReg FP \"", "<<", "CurReg", "<<", "\"\\n\"", ")", ";", "MFI", ".", "addPReg", "(", "WebAssembly", "::", "FP32", ",", "CurReg", "++", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "\"Arg VReg \"", "0", "\" -> WAReg \"", "1", "\"\\n\"", "0", "1", "0", "0", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"", "WebAssembly", "\"VReg \"", "\" -> WAReg \"", "\"\\n\"", "0", "\"PReg SP \"", "\"\\n\"", "WebAssembly::SP32", "\"PReg FP \"", "\"\\n\"", "WebAssembly::FP32" ]

[]

[ "<s>", "static", "bool", "nds32_fp_as_gp_check_available", "(", "void", ")", "{", "basic_block", "bb", ";", "basic_block", "exit_bb", ";", "edge_iterator", "ei", ";", "edge", "e", ";", "bool", "first_exit_blocks_p", ";", "if", "(", "TARGET_FORBID_FP_AS_GP", "||", "nds32_naked_function_p", "(", "current_function_decl", ")", "||", "!", "optimize_size", "||", "frame_pointer_needed", "||", "NDS32_REQUIRED_CALLEE_SAVED_P", "(", "FP_REGNUM", ")", "||", "(", "cfun", "->", "stdarg", "==", "1", ")", "||", "(", "find_fallthru_edge", "(", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "==", "NULL", ")", ")", "return", "false", ";", "first_exit_blocks_p", "=", "true", ";", "exit_bb", "=", "NULL", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "EXIT_BLOCK_PTR_FOR_FN", "(", "cfun", ")", "->", "preds", ")", "{", "if", "(", "!", "first_exit_blocks_p", ")", "return", "false", ";", "exit_bb", "=", "e", "->", "src", ";", "first_exit_blocks_p", "=", "false", ";", "}", "if", "(", "!", "exit_bb", ")", "return", "false", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "if", "(", "!", "dominated_by_p", "(", "CDI_POST_DOMINATORS", ",", "bb", ",", "exit_bb", ")", ")", "return", "false", ";", "}", "if", "(", "TARGET_FORCE_FP_AS_GP", ")", "{", "return", "true", ";", "}", "else", "{", "bool", "good_gain", "=", "false", ";", "int", "symbol_count", ";", "int", "threshold", ";", "if", "(", "flag_pic", "||", "nds32_have_prologue_p", "(", ")", ")", "{", "threshold", "=", "3", ";", "}", "else", "{", "threshold", "=", "5", "+", "(", "TARGET_V3PUSH", "?", "0", ":", "2", ")", ";", "}", "symbol_count", "=", "nds32_get_symbol_count", "(", ")", ";", "if", "(", "symbol_count", ">=", "threshold", ")", "good_gain", "=", "true", ";", "return", "good_gain", ";", "}", "}", "</s>" ]

[ "Function", "to", "determine", "whether", "it", "is", "worth", "to", "do", "fp_as_gp", "optimization", ".", "Return", "0", ":", "It", "is", "NOT", "worth", "to", "do", "fp_as_gp", "optimization", ".", "Return", "1", ":", "It", "is", "APPROXIMATELY", "worth", "to", "do", "fp_as_gp", "optimization", ".", "Note", "that", "if", "it", "is", "worth", "to", "do", "fp_as_gp", "optimization", ",", "we", "MUST", "set", "FP_REGNUM", "ever", "live", "in", "this", "function", "." ]

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

[]

[ "<s>", "bool", "HexagonOptAddrMode", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "HII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetOperandInfo", "TOI", "(", "*", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "*", "HII", ",", "TRI", ",", "*", "MDT", ",", "MDF", ",", "TOI", ")", ";", "G", ".", "build", "(", "BuildOptions", "::", "KeepDeadPhis", ")", ";", "DFG", "=", "&", "G", ";", "Liveness", "L", "(", "MRI", ",", "*", "DFG", ")", ";", "L", ".", "computePhiInfo", "(", ")", ";", "LV", "=", "&", "L", ";", "Deleted", ".", "clear", "(", ")", ";", "NodeAddr", "<", "FuncNode", "*", ">", "FA", "=", "DFG", "->", "getFunc", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"==== [RefMap#]=====:\\n \"", "<<", "Print", "<", "NodeAddr", "<", "FuncNode", "*", ">>", "(", "FA", ",", "*", "DFG", ")", "<<", "\"\\n\"", ")", ";", "for", "(", "NodeAddr", "<", "BlockNode", "*", ">", "BA", ":", "FA", ".", "Addr", "->", "members", "(", "*", "DFG", ")", ")", "Changed", "|=", "processBlock", "(", "BA", ")", ";", "for", "(", "auto", "MI", ":", "Deleted", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "if", "(", "Changed", ")", "{", "G", ".", "build", "(", ")", ";", "L", ".", "computeLiveIns", "(", ")", ";", "L", ".", "resetLiveIns", "(", ")", ";", "L", ".", "resetKills", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"==== [RefMap#]=====:\\n \"", "\"\\n\"" ]

[]

[ "<s>", "machine_mode", "mips_hard_regno_caller_save_mode", "(", "unsigned", "int", "regno", ",", "unsigned", "int", "nregs", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "choose_hard_reg_mode", "(", "regno", ",", "nregs", ",", "false", ")", ";", "else", "return", "mode", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_CALLER_SAVE_MODE", "." ]

[ "mips" ]

[]

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

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

[ "Patmos" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "LB", ":", "case", "RISCV", "::", "LBU", ":", "case", "RISCV", "::", "LH", ":", "case", "RISCV", "::", "LHU", ":", "case", "RISCV", "::", "FLH", ":", "case", "RISCV", "::", "LW", ":", "case", "RISCV", "::", "FLW", ":", "case", "RISCV", "::", "LWU", ":", "case", "RISCV", "::", "LD", ":", "case", "RISCV", "::", "FLD", ":", "break", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "0", "RISCV::LB", "RISCV::LBU", "RISCV::LH", "RISCV::LHU", "RISCV::FLH", "RISCV::LW", "RISCV::FLW", "RISCV::LWU", "RISCV::LD", "RISCV::FLD", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "DataLayoutPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "(", "\"stack-protector\"", ")", ";", "AU", ".", "addPreserved", "<", "MachineFunctionAnalysis", ">", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "\"stack-protector\"" ]

[]

[ "<s>", "const", "DigitalSubtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "DefaultSubtarget", ";", "}", "</s>" ]

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

[ "Digital" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "AARCH64_EXPAND_PSEUDO_NAME", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "MVT", "MipsTargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "isABI_O32", "(", ")", ")", "{", "return", "MVT", "::", "i32", ";", "}", "else", "{", "return", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "32", ")", "?", "MVT", "::", "i32", ":", "MVT", "::", "i64", ";", "}", "}", "return", "MipsTargetLowering", "::", "getRegisterType", "(", "Context", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "Mips", "Mips", "MVT::i32", "32", "MVT::i32", "MVT::i64", "Mips" ]

[]

[ "<s>", "bool", "WebAssemblyReplacePhysRegs", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Replace Physical Registers **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TRI", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "MRI", ".", "invalidateLiveness", "(", ")", ";", "for", "(", "unsigned", "PReg", "=", "WebAssembly", "::", "NoRegister", "+", "1", ";", "PReg", "<", "WebAssembly", "::", "NUM_TARGET_REGS", ";", "++", "PReg", ")", "{", "if", "(", "PReg", "==", "WebAssembly", "::", "VALUE_STACK", "||", "PReg", "==", "WebAssembly", "::", "ARGUMENTS", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "PReg", ")", ";", "unsigned", "VReg", "=", "WebAssembly", "::", "NoRegister", ";", "for", "(", "auto", "I", "=", "MRI", ".", "reg_begin", "(", "PReg", ")", ",", "E", "=", "MRI", ".", "reg_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", "++", ";", "if", "(", "!", "MO", ".", "isImplicit", "(", ")", ")", "{", "if", "(", "VReg", "==", "WebAssembly", "::", "NoRegister", ")", "VReg", "=", "MRI", ".", "createVirtualRegister", "(", "RC", ")", ";", "MO", ".", "setReg", "(", "VReg", ")", ";", "if", "(", "MO", ".", "getParent", "(", ")", "->", "isDebugValue", "(", ")", ")", "MO", ".", "setIsDebug", "(", ")", ";", "Changed", "=", "true", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Replace Physical Registers **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "WebAssembly::NoRegister", "1", "WebAssembly::NUM_TARGET_REGS", "WebAssembly::VALUE_STACK", "WebAssembly::ARGUMENTS", "WebAssembly::NoRegister", "WebAssembly::NoRegister" ]

[]

[ "<s>", "void", "v850_output_common", "(", "FILE", "*", "file", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "size", ",", "int", "align", ")", "{", "if", "(", "decl", "==", "NULL_TREE", ")", "{", "fprintf", "(", "file", ",", "\"%s\"", ",", "COMMON_ASM_OP", ")", ";", "}", "else", "{", "switch", "(", "v850_get_data_area", "(", "decl", ")", ")", "{", "case", "DATA_AREA_ZDA", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "ZCOMMON_ASM_OP", ")", ";", "break", ";", "case", "DATA_AREA_SDA", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "SCOMMON_ASM_OP", ")", ";", "break", ";", "case", "DATA_AREA_TDA", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "TCOMMON_ASM_OP", ")", ";", "break", ";", "default", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "COMMON_ASM_OP", ")", ";", "break", ";", "}", "}", "assemble_name", "(", "file", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\",%u,%u\\n\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "Called", "via", "the", "macro", "ASM_OUTPUT_DECL_COMMON" ]

[ "v850", "\"%s\"", "\"%s\"", "\"%s\"", "\"%s\"", "\"%s\"", "\",%u,%u\\n\"" ]

[]

[ "<s>", "bool", "MCS51AsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "MCS51", "::", "fixup_7_pcrel", ":", "case", "MCS51", "::", "fixup_13_pcrel", ":", "case", "MCS51", "::", "fixup_call", ":", "return", "true", ";", "}", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51::fixup_7_pcrel", "MCS51::fixup_13_pcrel", "MCS51::fixup_call" ]

[]

[ "<s>", "static", "machine_mode", "nvptx_preferred_simd_mode", "(", "scalar_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "V2DImode", ";", "case", "E_SImode", ":", "return", "V2SImode", ";", "default", ":", "return", "default_preferred_simd_mode", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "preferred", "mode", "for", "vectorizing", "scalar", "MODE", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "PatmosSinglePathInfo", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "if", "(", "Root", ")", "{", "delete", "Root", ";", "Root", "=", "NULL", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos" ]

[]

[ "<s>", "function_symbol_result", "function_symbol", "(", "rtx", "target", ",", "const", "char", "*", "name", ",", "sh_function_kind", "kind", ")", "{", "if", "(", "kind", "!=", "FUNCTION_ORDINARY", ")", "name", "=", "IDENTIFIER_POINTER", "(", "get_identifier", "(", "name", ")", ")", ";", "rtx", "sym", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "name", ")", ";", "rtx", "lab", "=", "const0_rtx", ";", "SYMBOL_REF_FLAGS", "(", "sym", ")", "=", "SYMBOL_FLAG_FUNCTION", ";", "if", "(", "flag_pic", ")", "switch", "(", "kind", ")", "{", "case", "FUNCTION_ORDINARY", ":", "break", ";", "case", "SFUNC_GOT", ":", "{", "rtx", "reg", "=", "target", "?", "target", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_symGOT2reg", "(", "reg", ",", "sym", ")", ")", ";", "sym", "=", "reg", ";", "break", ";", "}", "case", "SFUNC_STATIC", ":", "{", "rtx", "reg", "=", "target", "?", "target", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "TARGET_FDPIC", ")", "{", "lab", "=", "PATTERN", "(", "gen_call_site", "(", ")", ")", ";", "emit_insn", "(", "gen_sym_label2reg", "(", "reg", ",", "sym", ",", "lab", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_symGOTOFF2reg", "(", "reg", ",", "sym", ")", ")", ";", "}", "sym", "=", "reg", ";", "break", ";", "}", "}", "if", "(", "target", "&&", "sym", "!=", "target", ")", "{", "emit_move_insn", "(", "target", ",", "sym", ")", ";", "return", "function_symbol_result", "(", "target", ",", "lab", ")", ";", "}", "return", "function_symbol_result", "(", "sym", ",", "lab", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "pair", "for", "the", "address", "and", "call", "site", "label", "of", "a", "function", "NAME", "of", "kind", "KIND", ",", "placing", "the", "result", "in", "TARGET", "if", "not", "NULL", ".", "For", "SFUNC_STATIC", ",", "if", "FDPIC", ",", "the", "LAB", "member", "of", "result", "will", "be", "set", "to", "(", "const_int", "0", ")", "if", "jsr", "should", "be", "used", ",", "or", "a", "label_ref", "if", "bsrf", "should", "be", "used", ".", "For", "FDPIC", ",", "both", "SFUNC_GOT", "and", "SFUNC_STATIC", "will", "return", "the", "address", "of", "the", "function", "itself", ",", "not", "a", "function", "descriptor", ",", "so", "they", "can", "only", "be", "used", "with", "functions", "not", "using", "the", "FDPIC", "register", "that", "are", "known", "to", "be", "called", "directory", "without", "a", "PLT", "entry", "." ]

[ "sh" ]

[]

[ "<s>", "unsigned", "int", "rs6000_special_round_type_align", "(", "tree", "type", ",", "unsigned", "int", "computed", ",", "unsigned", "int", "specified", ")", "{", "unsigned", "int", "align", "=", "MAX", "(", "computed", ",", "specified", ")", ";", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "field", "!=", "NULL", "&&", "field", "!=", "type", ")", "{", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "type", "!=", "error_mark_node", "&&", "TYPE_MODE", "(", "type", ")", "==", "DFmode", ")", "align", "=", "MAX", "(", "align", ",", "64", ")", ";", "}", "return", "align", ";", "}", "</s>" ]

[ "Darwin", ",", "AIX", "increases", "natural", "record", "alignment", "to", "doubleword", "if", "the", "first", "field", "is", "an", "FP", "double", "while", "the", "FP", "fields", "remain", "word", "aligned", "." ]

[ "rs6000", "64" ]

[]

[ "<s>", "void", "RISCVAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "if", "(", "!", "lowerRISCVMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ")", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "getPreferredVectorAction", "(", "EVT", "VT", ")", "const", "override", "{", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "8", "==", "0", ")", "return", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "8", "0" ]

[]

[ "<s>", "bool", "runOnFunction", "(", "Function", "&", "F", ")", "override", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "PHINodeSet", "PromotablePHINodes", "=", "getPromotablePHINodes", "(", "F", ")", ";", "B2IMap", "Bool2IntMap", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "if", "(", "auto", "*", "R", "=", "dyn_cast", "<", "ReturnInst", ">", "(", "&", "I", ")", ")", "if", "(", "F", ".", "getReturnType", "(", ")", "->", "isIntegerTy", "(", "1", ")", ")", "Changed", "|=", "runOnUse", "(", "R", "->", "getOperandUse", "(", "0", ")", ",", "PromotablePHINodes", ",", "Bool2IntMap", ")", ";", "if", "(", "auto", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "&", "I", ")", ")", "for", "(", "auto", "&", "U", ":", "CI", "->", "operands", "(", ")", ")", "if", "(", "U", "->", "getType", "(", ")", "->", "isIntegerTy", "(", "1", ")", ")", "Changed", "|=", "runOnUse", "(", "U", ",", "PromotablePHINodes", ",", "Bool2IntMap", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "PowerPC", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "rs6000_builtin_support_vector_misalignment", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "misalignment", ",", "bool", "is_packed", ")", "{", "if", "(", "TARGET_VSX", ")", "{", "if", "(", "TARGET_EFFICIENT_UNALIGNED_VSX", ")", "return", "true", ";", "if", "(", "optab_handler", "(", "movmisalign_optab", ",", "mode", ")", "==", "CODE_FOR_nothing", ")", "return", "false", ";", "if", "(", "misalignment", "==", "-", "1", ")", "{", "if", "(", "rs6000_vector_alignment_reachable", "(", "type", ",", "is_packed", ")", ")", "{", "int", "element_size", "=", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "type", ")", ")", ";", "if", "(", "element_size", "==", "64", "||", "element_size", "==", "32", ")", "return", "true", ";", "}", "return", "false", ";", "}", "if", "(", "misalignment", "%", "4", "==", "0", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "vector", "misalignment", "factor", "is", "supported", "by", "the", "target", "." ]

[ "powerpcspe", "1", "64", "32", "4", "0" ]

[]

[ "<s>", "bool", "Z80AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "if", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "this", "->", "STI", ")", ";", "return", "false", ";", "}", "return", "Error", "(", "IDLoc", ",", "\"Failed to parse instruction\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Failed to parse instruction\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"X86 Byte/Word Instruction Fixup\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 Byte/Word Instruction Fixup\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Hexagon Copy-To-Combine Pass\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon Copy-To-Combine Pass\"" ]

[]

[ "<s>", "bool", "MipsFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "MF", "->", "begin", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", "||", "Reg", "==", "Mips", "::", "RA_64", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "bool", "IsKill", "=", "!", "IsRAAndRetAddrIsTaken", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "*", "EntryBlock", ",", "MI", ",", "Reg", ",", "IsKill", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "}", "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", "(", ")", "." ]

[ "Mips", "Mips", "0", "Mips::RA", "Mips::RA_64" ]

[]

[ "<s>", "static", "rtx", "mmix_function_value", "(", "const_tree", "valtype", ",", "const_tree", "func", "ATTRIBUTE_UNUSED", ",", "bool", "outgoing", ")", "{", "machine_mode", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "machine_mode", "cmode", ";", "int", "first_val_regnum", "=", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", ";", "rtx", "vec", "[", "MMIX_MAX_REGS_FOR_VALUE", "]", ";", "int", "i", ";", "int", "nregs", ";", "if", "(", "!", "outgoing", ")", "return", "gen_rtx_REG", "(", "mode", ",", "MMIX_RETURN_VALUE_REGNUM", ")", ";", "if", "(", "TARGET_ABI_GNU", "||", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "BITS_PER_WORD", ")", "return", "gen_rtx_REG", "(", "mode", ",", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", ")", ";", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "cmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "valtype", ")", ")", ";", "else", "{", "if", "(", "mode", "!=", "TImode", ")", "sorry", "(", "\"support for mode %qs\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "cmode", "=", "DImode", ";", "}", "nregs", "=", "(", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "+", "BITS_PER_WORD", "-", "1", ")", "/", "BITS_PER_WORD", ")", ";", "if", "(", "nregs", ">", "MMIX_MAX_REGS_FOR_VALUE", ")", "internal_error", "(", "\"too large function value type, needs %d registers,\\ have only %d registers for this\"", ",", "nregs", ",", "MMIX_MAX_REGS_FOR_VALUE", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nregs", "-", "1", ";", "i", "++", ")", "vec", "[", "i", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "first_val_regnum", "+", "i", ")", ",", "GEN_INT", "(", "(", "i", "+", "1", ")", "*", "BITS_PER_UNIT", ")", ")", ";", "vec", "[", "nregs", "-", "1", "]", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "cmode", ",", "first_val_regnum", "+", "nregs", "-", "1", ")", ",", "const0_rtx", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec_v", "(", "nregs", ",", "vec", ")", ")", ";", "}", "</s>" ]

[ "Implements", "TARGET_FUNCTION_VALUE", "." ]

[ "mmix", "\"support for mode %qs\"", "1", "\"too large function value type, needs %d registers,\\ have only %d registers for this\"", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "static", "rtx", "arm_gen_multiple_op", "(", "bool", "is_load", ",", "int", "*", "regs", ",", "int", "count", ",", "rtx", "basereg", ",", "bool", "write_back", ",", "rtx", "basemem", ",", "HOST_WIDE_INT", "*", "offsetp", ")", "{", "rtx", "mems", "[", "MAX_LDM_STM_OPS", "]", ";", "HOST_WIDE_INT", "offset", "=", "*", "offsetp", ";", "int", "i", ";", "gcc_assert", "(", "count", "<=", "MAX_LDM_STM_OPS", ")", ";", "if", "(", "GET_CODE", "(", "basereg", ")", "==", "PLUS", ")", "basereg", "=", "XEXP", "(", "basereg", ",", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "basereg", ",", "i", "*", "4", ")", ";", "mems", "[", "i", "]", "=", "adjust_automodify_address_nv", "(", "basemem", ",", "SImode", ",", "addr", ",", "offset", ")", ";", "offset", "+=", "4", ";", "}", "if", "(", "write_back", ")", "*", "offsetp", "=", "offset", ";", "if", "(", "is_load", ")", "return", "arm_gen_load_multiple_1", "(", "count", ",", "regs", ",", "mems", ",", "basereg", ",", "write_back", "?", "4", "*", "count", ":", "0", ")", ";", "else", "return", "arm_gen_store_multiple_1", "(", "count", ",", "regs", ",", "mems", ",", "basereg", ",", "write_back", "?", "4", "*", "count", ":", "0", ")", ";", "}", "</s>" ]

[ "Generate", "either", "a", "load-multiple", "or", "a", "store-multiple", "instruction", ".", "This", "function", "can", "be", "used", "in", "situations", "where", "we", "can", "start", "with", "a", "single", "MEM", "rtx", "and", "adjust", "its", "address", "upwards", ".", "COUNT", "is", "the", "number", "of", "operations", "in", "the", "instruction", ",", "not", "counting", "a", "possible", "update", "of", "the", "base", "register", ".", "REGS", "is", "an", "array", "containing", "the", "register", "operands", ".", "BASEREG", "is", "the", "base", "register", "to", "be", "used", "in", "addressing", "the", "memory", "operands", ",", "which", "are", "constructed", "from", "BASEMEM", ".", "WRITE_BACK", "specifies", "whether", "the", "generated", "instruction", "should", "include", "an", "update", "of", "the", "base", "register", ".", "OFFSETP", "is", "used", "to", "pass", "an", "offset", "to", "and", "from", "this", "function", ";", "this", "offset", "is", "not", "used", "when", "constructing", "the", "address", "(", "instead", "BASEMEM", "should", "have", "an", "appropriate", "offset", "in", "its", "address", ")", ",", "it", "is", "used", "only", "for", "setting", "MEM_OFFSET", ".", "It", "is", "updated", "only", "if", "WRITE_BACK", "is", "true", "." ]

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

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "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", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MFI", "->", "setCalleeSavedFrameSize", "(", "CSI", ".", "size", "(", ")", "*", "2", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "PUSH16r", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ";", "}", "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", "(", ")", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "2", "0", "1", "MSP430::PUSH16r" ]

[]

[ "<s>", "bool", "exp2_immediate_p", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "int", "low", ",", "int", "high", ")", "{", "machine_mode", "int_mode", ";", "HOST_WIDE_INT", "val", ";", "unsigned", "char", "arr", "[", "16", "]", ";", "int", "bytes", ",", "i", ",", "j", ";", "gcc_assert", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "||", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", "||", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", "&&", "!", "const_vector_immediate_p", "(", "op", ")", ")", "return", "0", ";", "if", "(", "GET_MODE", "(", "op", ")", "!=", "VOIDmode", ")", "mode", "=", "GET_MODE", "(", "op", ")", ";", "constant_to_array", "(", "mode", ",", "op", ",", "arr", ")", ";", "mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "int_mode", "=", "mode_for_size", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "MODE_INT", ",", "0", ")", ";", "for", "(", "i", "=", "bytes", ";", "i", "<", "16", ";", "i", "+=", "bytes", ")", "for", "(", "j", "=", "0", ";", "j", "<", "bytes", ";", "j", "++", ")", "if", "(", "arr", "[", "j", "]", "!=", "arr", "[", "i", "+", "j", "]", ")", "return", "0", ";", "val", "=", "arr", "[", "0", "]", ";", "for", "(", "j", "=", "1", ";", "j", "<", "bytes", ";", "j", "++", ")", "val", "=", "(", "val", "<<", "8", ")", "|", "arr", "[", "j", "]", ";", "val", "=", "trunc_int_for_mode", "(", "val", ",", "int_mode", ")", ";", "gcc_assert", "(", "mode", "==", "SFmode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "{", "int", "exp", "=", "(", "val", ">>", "23", ")", "-", "127", ";", "return", "val", ">", "0", "&&", "(", "val", "&", "0x007fffff", ")", "==", "0", "&&", "exp", ">=", "low", "&&", "exp", "<=", "high", ";", "}", "return", "FALSE", ";", "}", "</s>" ]

[ "TRUE", "when", "op", "is", "an", "immediate", "and", "an", "exact", "power", "of", "2", ",", "and", "given", "that", "OP", "is", "2^scale", ",", "scale", ">", "=", "LOW", "&", "&", "scale", "<", "=", "HIGH", ".", "When", "OP", "is", "a", "vector", ",", "all", "entries", "must", "be", "the", "same", "." ]

[ "spu", "16", "0", "0", "16", "0", "0", "0", "1", "8", "23", "127", "0", "0x007fffff", "0" ]

[]

[ "<s>", "bool", "HexagonVectorLoopCarriedReuse", "::", "run", "(", ")", "{", "if", "(", "!", "CurLoop", "->", "getLoopPreheader", "(", ")", ")", "return", "false", ";", "if", "(", "!", "CurLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "CurLoop", "->", "getNumBlocks", "(", ")", "!=", "1", ")", "return", "false", ";", "return", "doVLCR", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "LanaiAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", ",", "uint64_t", "Value", ",", "bool", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "static_cast", "<", "unsigned", ">", "(", "Kind", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", "=", "4", ";", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "static_cast", "<", "uint64_t", ">", "(", "static_cast", "<", "uint8_t", ">", "(", "Data", "[", "Offset", "+", "Idx", "]", ")", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "static_cast", "<", "uint64_t", ">", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "static_cast", "<", "uint8_t", ">", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "Lanai", "Lanai", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "void", "GBZ80TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "Base", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "TextSection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".text\"", ")", ",", "GBSectionType", "::", "ST_ROM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "DataSection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".data\"", ")", ",", "GBSectionType", "::", "ST_WRAM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "BSSSection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".bss\"", ")", ",", "GBSectionType", "::", "ST_WRAM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "ReadOnlySection", "=", "getSection", "(", "SectionKind", "::", "getText", "(", ")", ",", "StringRef", "(", "\".readonly\"", ")", ",", "GBSectionType", "::", "ST_ROM0", ",", "0", ",", "~", "0U", ",", "1", ",", "nullptr", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "\".text\"", "GBSectionType::ST_ROM0", "0", "0U", "1", "\".data\"", "GBSectionType::ST_WRAM0", "0", "0U", "1", "\".bss\"", "GBSectionType::ST_WRAM0", "0", "0U", "1", "\".readonly\"", "GBSectionType::ST_ROM0", "0", "0U", "1" ]

[]

[ "<s>", "void", "AArch64AppleInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "StringRef", "Layout", ";", "bool", "IsTbx", ";", "if", "(", "isTblTbxInstruction", "(", "MI", "->", "getOpcode", "(", ")", ",", "Layout", ",", "IsTbx", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "(", "IsTbx", "?", "\"tbx\"", ":", "\"tbl\"", ")", "<<", "Layout", "<<", "'\\t'", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", "<<", "\", \"", ";", "unsigned", "ListOpNum", "=", "IsTbx", "?", "2", ":", "1", ";", "printVectorList", "(", "MI", ",", "ListOpNum", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "ListOpNum", "+", "1", ")", ".", "getReg", "(", ")", ",", "AArch64", "::", "vreg", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "if", "(", "const", "LdStNInstrDesc", "*", "LdStDesc", "=", "getLdStNInstrDesc", "(", "Opcode", ")", ")", "{", "O", "<<", "\"\\t\"", "<<", "LdStDesc", "->", "Mnemonic", "<<", "LdStDesc", "->", "Layout", "<<", "'\\t'", ";", "int", "OpNum", "=", "LdStDesc", "->", "ListOperand", ";", "printVectorList", "(", "MI", ",", "OpNum", "++", ",", "STI", ",", "O", ",", "\"\"", ")", ";", "if", "(", "LdStDesc", "->", "HasLane", ")", "O", "<<", "'['", "<<", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getImm", "(", ")", "<<", "']'", ";", "unsigned", "AddrReg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "O", "<<", "\", [\"", "<<", "getRegisterName", "(", "AddrReg", ")", "<<", "']'", ";", "if", "(", "LdStDesc", "->", "NaturalOffset", "!=", "0", ")", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "++", ")", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "!=", "AArch64", "::", "XZR", ")", "O", "<<", "\", \"", "<<", "getRegisterName", "(", "Reg", ")", ";", "else", "{", "assert", "(", "LdStDesc", "->", "NaturalOffset", "&&", "\"no offset on post-inc instruction?\"", ")", ";", "O", "<<", "\", #\"", "<<", "LdStDesc", "->", "NaturalOffset", ";", "}", "}", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "return", ";", "}", "AArch64InstPrinter", "::", "printInst", "(", "MI", ",", "O", ",", "Annot", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"\\t\"", "\"tbx\"", "\"tbl\"", "0", "AArch64::vreg", "\", \"", "2", "1", "\"\"", "\", \"", "1", "AArch64::vreg", "\"\\t\"", "\"\"", "\", [\"", "0", "AArch64::XZR", "\", \"", "\"no offset on post-inc instruction?\"", "\", #\"", "AArch64" ]

[]

[ "<s>", "void", "M680x0ELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "M680x0TargetMachine", "&", ">", "(", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0", "M680x0", "\".sdata\"", "\".sbss\"" ]

[]

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

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

[ "M68k", "M68k", "0" ]

[]

[ "<s>", "bool", "X86AtomicExpandPass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "SmallVector", "<", "Instruction", "*", ",", "1", ">", "AtomicInsts", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "for", "(", "Instruction", "&", "Inst", ":", "BB", ")", "{", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "&", "Inst", ")", "||", "(", "isa", "<", "StoreInst", ">", "(", "&", "Inst", ")", "&&", "cast", "<", "StoreInst", ">", "(", "&", "Inst", ")", "->", "isAtomic", "(", ")", ")", ")", "AtomicInsts", ".", "push_back", "(", "&", "Inst", ")", ";", "}", "bool", "MadeChange", "=", "false", ";", "for", "(", "Instruction", "*", "Inst", ":", "AtomicInsts", ")", "{", "if", "(", "!", "shouldExpand", "(", "Inst", ")", ")", "continue", ";", "if", "(", "AtomicRMWInst", "*", "AI", "=", "dyn_cast", "<", "AtomicRMWInst", ">", "(", "Inst", ")", ")", "MadeChange", "|=", "expandAtomicRMW", "(", "AI", ")", ";", "if", "(", "StoreInst", "*", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "Inst", ")", ")", "MadeChange", "|=", "expandAtomicStore", "(", "SI", ")", ";", "assert", "(", "MadeChange", "&&", "\"Atomic inst not expanded when it should be?\"", ")", ";", "Inst", "->", "eraseFromParent", "(", ")", ";", "}", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "X86", "X86", "1", "\"Atomic inst not expanded when it should be?\"" ]

[]

[ "<s>", "static", "bool", "cdx_add_immed", "(", "rtx", "op", ")", "{", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "{", "HOST_WIDE_INT", "ival", "=", "INTVAL", "(", "op", ")", ";", "return", "ival", "<=", "128", "&&", "ival", ">", "0", "&&", "(", "ival", "&", "(", "ival", "-", "1", ")", ")", "==", "0", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "OP", "is", "within", "range", "of", "CDX", "addi.n", "immediates", "." ]

[ "nios2", "128", "0", "1", "0" ]

[]

[ "<s>", "Relocator", "::", "Size", "AArch64Relocator", "::", "getSize", "(", "Relocation", "::", "Type", "pType", ")", "const", "{", "return", "ApplyFunctions", "[", "pType", "]", ".", "size", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "bytes", "in", "the", "encoding", "of", "this", "instruction", ",", "or", "zero", "if", "the", "encoding", "size", "can", "not", "be", "known", "from", "the", "opcode", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "F2003fMCAsmStreamer", "::", "AddComment", "(", "const", "Twine", "&", "T", ",", "bool", "EOL", ")", "{", "if", "(", "!", "IsVerboseAsm", ")", "return", ";", "T", ".", "toVector", "(", "CommentToEmit", ")", ";", "if", "(", "EOL", ")", "CommentToEmit", ".", "push_back", "(", "'\\n'", ")", ";", "}", "</s>" ]

[ "Add", "a", "textual", "comment", "." ]

[ "F2003f", "F2003f" ]

[]

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

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

[ "SystemZ" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "ARMBankConflictHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "&", "L0", "=", "*", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "L0", ".", "mayLoad", "(", ")", "||", "L0", ".", "mayStore", "(", ")", "||", "L0", ".", "getNumMemOperands", "(", ")", "!=", "1", ")", "return", "NoHazard", ";", "auto", "MO0", "=", "*", "L0", ".", "memoperands", "(", ")", ".", "begin", "(", ")", ";", "auto", "BaseVal0", "=", "MO0", "->", "getValue", "(", ")", ";", "auto", "BasePseudoVal0", "=", "MO0", "->", "getPseudoValue", "(", ")", ";", "int64_t", "Offset0", "=", "0", ";", "if", "(", "MO0", "->", "getSize", "(", ")", ">", "4", ")", "return", "NoHazard", ";", "bool", "SPvalid", "=", "false", ";", "const", "MachineOperand", "*", "SP", "=", "nullptr", ";", "int64_t", "SPOffset0", "=", "0", ";", "for", "(", "auto", "L1", ":", "Accesses", ")", "{", "auto", "MO1", "=", "*", "L1", "->", "memoperands", "(", ")", ".", "begin", "(", ")", ";", "auto", "BaseVal1", "=", "MO1", "->", "getValue", "(", ")", ";", "auto", "BasePseudoVal1", "=", "MO1", "->", "getPseudoValue", "(", ")", ";", "int64_t", "Offset1", "=", "0", ";", "if", "(", "BaseVal0", "&&", "BaseVal1", ")", "{", "const", "Value", "*", "Ptr0", ",", "*", "Ptr1", ";", "Ptr0", "=", "GetPointerBaseWithConstantOffset", "(", "BaseVal0", ",", "Offset0", ",", "DL", ",", "true", ")", ";", "Ptr1", "=", "GetPointerBaseWithConstantOffset", "(", "BaseVal1", ",", "Offset1", ",", "DL", ",", "true", ")", ";", "if", "(", "Ptr0", "==", "Ptr1", "&&", "Ptr0", ")", "return", "CheckOffsets", "(", "Offset0", ",", "Offset1", ")", ";", "}", "if", "(", "BasePseudoVal0", "&&", "BasePseudoVal1", "&&", "BasePseudoVal0", "->", "kind", "(", ")", "==", "BasePseudoVal1", "->", "kind", "(", ")", "&&", "BasePseudoVal0", "->", "kind", "(", ")", "==", "PseudoSourceValue", "::", "FixedStack", ")", "{", "auto", "FS0", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "BasePseudoVal0", ")", ";", "auto", "FS1", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "BasePseudoVal1", ")", ";", "Offset0", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FS0", "->", "getFrameIndex", "(", ")", ")", ";", "Offset1", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FS1", "->", "getFrameIndex", "(", ")", ")", ";", "return", "CheckOffsets", "(", "Offset0", ",", "Offset1", ")", ";", "}", "if", "(", "BasePseudoVal0", "&&", "BasePseudoVal1", "&&", "BasePseudoVal0", "->", "kind", "(", ")", "==", "BasePseudoVal1", "->", "kind", "(", ")", "&&", "BasePseudoVal0", "->", "isConstantPool", "(", ")", "&&", "AssumeITCMBankConflict", ")", "return", "Hazard", ";", "if", "(", "!", "SPvalid", ")", "{", "if", "(", "!", "getBaseOffset", "(", "L0", ",", "SP", ",", "SPOffset0", ")", "||", "SP", "->", "getReg", "(", ")", ".", "id", "(", ")", "!=", "ARM", "::", "SP", ")", "SP", "=", "nullptr", ";", "SPvalid", "=", "true", ";", "}", "if", "(", "SP", ")", "{", "int64_t", "SPOffset1", ";", "const", "MachineOperand", "*", "SP1", ";", "if", "(", "getBaseOffset", "(", "*", "L1", ",", "SP1", ",", "SPOffset1", ")", "&&", "SP1", "->", "getReg", "(", ")", ".", "id", "(", ")", "==", "ARM", "::", "SP", ")", "return", "CheckOffsets", "(", "SPOffset0", ",", "SPOffset1", ")", ";", "}", "}", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "ARM", "ARM", "1", "0", "4", "0", "0", "ARM::SP", "ARM::SP" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "LoadOpcode", ",", "StoreOpcode", ";", "getLoadStoreOpcodes", "(", "RC", ",", "LoadOpcode", ",", "StoreOpcode", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "get", "(", "StoreOpcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<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", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR_64", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "OR_pp", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "SrcReg", "==", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFRI", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "else", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFR", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_loreg", ")", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFRI", ")", ",", "(", "RI", ".", "getSubReg", "(", "DestReg", ",", "Hexagon", "::", "subreg_hireg", ")", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "return", ";", "}", "if", "(", "Hexagon", "::", "CRRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "TFCR", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "return", ";", "}", "assert", "(", "0", "&&", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::TFR", "Hexagon::DoubleRegsRegClass", "Hexagon::TFR_64", "Hexagon::PredRegsRegClass", "Hexagon::OR_pp", "Hexagon::DoubleRegsRegClass", "Hexagon::subreg_loreg", "Hexagon::TFRI", "Hexagon::subreg_hireg", "0", "Hexagon::TFR", "Hexagon::subreg_loreg", "Hexagon::TFRI", "Hexagon::subreg_hireg", "0", "Hexagon::CRRegsRegClass", "Hexagon::TFCR", "0", "\"Unimplemented\"" ]

[]

[ "<s>", "unsigned", "int", "pass_bpf_core_attr", "::", "execute", "(", "function", "*", "fn", ")", "{", "handle_attr_preserve", "(", "fn", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "bpf", "0" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "if", "(", "IsLittleEndian", "&&", "Size", "==", "4", "&&", "IsMicroMips", ")", "{", "EmitInstruction", "(", "Val", ">>", "16", ",", "2", ",", "OS", ")", ";", "EmitInstruction", "(", "Val", ",", "2", ",", "OS", ")", ";", "}", "else", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Size", ";", "++", "i", ")", "{", "unsigned", "Shift", "=", "IsLittleEndian", "?", "i", "*", "8", ":", "(", "Size", "-", "1", "-", "i", ")", "*", "8", ";", "EmitByte", "(", "(", "Val", ">>", "Shift", ")", "&", "0xff", ",", "OS", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Mips", "4", "Mips", "16", "2", "2", "0", "8", "1", "8", "0xff" ]

[]

[ "<s>", "static", "int", "constant_pool_expr_1", "(", "rtx", "op", ",", "int", "*", "have_sym", ",", "int", "*", "have_toc", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "if", "(", "RS6000_SYMBOL_REF_TLS_P", "(", "op", ")", ")", "return", "0", ";", "else", "if", "(", "CONSTANT_POOL_ADDRESS_P", "(", "op", ")", ")", "{", "if", "(", "ASM_OUTPUT_SPECIAL_POOL_ENTRY_P", "(", "get_pool_constant", "(", "op", ")", ",", "Pmode", ")", ")", "{", "*", "have_sym", "=", "1", ";", "return", "1", ";", "}", "else", "return", "0", ";", "}", "else", "if", "(", "!", "strcmp", "(", "XSTR", "(", "op", ",", "0", ")", ",", "toc_label_name", ")", ")", "{", "*", "have_toc", "=", "1", ";", "return", "1", ";", "}", "else", "return", "0", ";", "case", "PLUS", ":", "case", "MINUS", ":", "return", "(", "constant_pool_expr_1", "(", "XEXP", "(", "op", ",", "0", ")", ",", "have_sym", ",", "have_toc", ")", "&&", "constant_pool_expr_1", "(", "XEXP", "(", "op", ",", "1", ")", ",", "have_sym", ",", "have_toc", ")", ")", ";", "case", "CONST", ":", "return", "constant_pool_expr_1", "(", "XEXP", "(", "op", ",", "0", ")", ",", "have_sym", ",", "have_toc", ")", ";", "case", "CONST_INT", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "AArch64_ELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "mem_operand_ds_form", "(", "rtx", "op", ",", "machine_mode", "mode", ")", "{", "unsigned", "HOST_WIDE_INT", "offset", ";", "int", "extra", ";", "rtx", "addr", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "!", "offsettable_address_p", "(", "false", ",", "mode", ",", "addr", ")", ")", "return", "false", ";", "op", "=", "address_offset", "(", "addr", ")", ";", "if", "(", "op", "==", "NULL_RTX", ")", "return", "true", ";", "offset", "=", "INTVAL", "(", "op", ")", ";", "if", "(", "(", "offset", "&", "3", ")", "!=", "0", ")", "return", "false", ";", "extra", "=", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ";", "if", "(", "extra", "<", "0", ")", "extra", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "offset", "=", "(", "(", "offset", "&", "0xffff", ")", "^", "0x8000", ")", "-", "0x8000", ";", "return", "offset", "+", "0x8000", "<", "0x10000u", "-", "extra", ";", "}", "</s>" ]

[ "As", "above", ",", "but", "for", "DS-FORM", "VSX", "insns", ".", "Unlike", "mem_operand_gpr", ",", "enforce", "an", "offset", "divisible", "by", "4", "even", "for", "32-bit", "." ]

[ "rs6000", "0", "3", "0", "0", "0", "0xffff", "0x8000", "0x8000", "0x8000", "0x10000u" ]

[]

[ "<s>", "void", "AAPFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "}", "</s>" ]

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

[ "AAP", "AAP" ]

[]

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

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

[ "AGC" ]

[]

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

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

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

[]

[ "<s>", "static", "struct", "machine_function", "*", "ix86_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "f", ";", "f", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "f", "->", "use_fast_prologue_epilogue_nregs", "=", "-", "1", ";", "f", "->", "call_abi", "=", "ix86_abi", ";", "return", "f", ";", "}", "</s>" ]

[ "Clear", "stack", "slot", "assignments", "remembered", "from", "previous", "functions", ".", "This", "is", "called", "from", "INIT_EXPANDERS", "once", "before", "RTL", "is", "emitted", "for", "each", "function", "." ]

[ "i386", "1" ]

[]

[ "<s>", "void", "arc_split_ior", "(", "rtx", "*", "operands", ")", "{", "unsigned", "HOST_WIDE_INT", "mask", ",", "maskx", ";", "rtx", "op1", "=", "operands", "[", "1", "]", ";", "gcc_assert", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", ";", "mask", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", "&", "0xffffffff", ";", "if", "(", "__builtin_popcount", "(", "mask", ")", ">", "3", "||", "(", "mask", "&", "0x3f", ")", ")", "{", "maskx", "=", "mask", "&", "0x3f", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "op1", "=", "operands", "[", "0", "]", ";", "mask", "&=", "~", "maskx", ";", "}", "switch", "(", "__builtin_popcount", "(", "mask", ")", ")", "{", "case", "3", ":", "maskx", "=", "1", "<<", "(", "__builtin_ffs", "(", "mask", ")", "-", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "mask", "&=", "~", "maskx", ";", "op1", "=", "operands", "[", "0", "]", ";", "case", "2", ":", "maskx", "=", "1", "<<", "(", "__builtin_ffs", "(", "mask", ")", "-", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "mask", "&=", "~", "maskx", ";", "op1", "=", "operands", "[", "0", "]", ";", "case", "1", ":", "maskx", "=", "1", "<<", "(", "__builtin_ffs", "(", "mask", ")", "-", "1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "GEN_INT", "(", "maskx", ")", ")", ")", ")", ";", "break", ";", "case", "0", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Split", "an", "OR", "instruction", "into", "multiple", "BSET/OR", "instructions", "in", "a", "attempt", "to", "avoid", "long", "immediate", "constants", ".", "The", "next", "strategies", "are", "employed", "when", "destination", "is", "'", "q", "'", "reg", ".", "1.", "if", "there", "are", "up", "to", "three", "bits", "set", "in", "the", "mask", ",", "a", "succession", "of", "three", "bset", "instruction", "will", "be", "emitted", ":", "OR", "rA", ",", "rB", ",", "mask", "-", ">", "BSET", "(", "_S", ")", "rA", ",", "rB", ",", "mask1/BSET_S", "rA", ",", "rA", ",", "mask2/BSET_S", "rA", ",", "rA", ",", "mask3", "2.", "if", "the", "lower", "6", "bits", "of", "the", "mask", "is", "set", "and", "there", "is", "only", "one", "bit", "set", "in", "the", "upper", "remaining", "bits", "then", "we", "will", "emit", "one", "bset", "and", "one", "OR", "instruction", ":", "OR", "rA", ",", "rB", ",", "mask", "-", ">", "OR", "rA", ",", "rB", ",", "mask1/BSET_S", "rA", ",", "mask2", "3.", "otherwise", "an", "OR", "with", "limm", "will", "be", "emmitted", "." ]

[ "arc", "1", "2", "2", "0xffffffff", "3", "0x3f", "0x3f", "0", "0", "3", "1", "1", "0", "0", "2", "1", "1", "0", "0", "1", "1", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "SparcAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "GOp", ",", "unsigned", "Kind", ")", "{", "SparcOperand", "*", "Op", "=", "(", "SparcOperand", "*", ")", "GOp", ";", "if", "(", "Op", "->", "isFloatOrDoubleReg", "(", ")", ")", "{", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK_DFPRegs", ":", "if", "(", "!", "Op", "->", "isFloatReg", "(", ")", "||", "SparcOperand", "::", "MorphToDoubleReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "Match_Success", ";", "break", ";", "case", "MCK_QFPRegs", ":", "if", "(", "SparcOperand", "::", "MorphToQuadReg", "(", "Op", ")", ")", "return", "MCTargetAsmParser", "::", "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", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "SparcOperand::MorphToDoubleReg", "SparcOperand::MorphToQuadReg" ]

[]

[ "<s>", "bool", "MipsInstrInfo", "::", "HasForbiddenSlot", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "return", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "MipsII", "::", "HasForbiddenSlot", ")", "!=", "0", ";", "}", "</s>" ]

[ "Predicate", "to", "determine", "if", "an", "instruction", "has", "a", "forbidden", "slot", "." ]

[ "Mips", "Mips", "MipsII::HasForbiddenSlot", "0" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "canInsertSelect", "(", "const", "MachineBasicBlock", "&", "MBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ",", "unsigned", "TrueReg", ",", "unsigned", "FalseReg", ",", "int", "&", "CondCycles", ",", "int", "&", "TrueCycles", ",", "int", "&", "FalseCycles", ")", "const", "{", "if", "(", "!", "STI", ".", "hasLoadStoreOnCond", "(", ")", ")", "return", "false", ";", "if", "(", "Pred", ".", "size", "(", ")", "!=", "2", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getCommonSubClass", "(", "MRI", ".", "getRegClass", "(", "TrueReg", ")", ",", "MRI", ".", "getRegClass", "(", "FalseReg", ")", ")", ";", "if", "(", "!", "RC", ")", "return", "false", ";", "if", "(", "(", "STI", ".", "hasLoadStoreOnCond2", "(", ")", "&&", "SystemZ", "::", "GRX32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "||", "SystemZ", "::", "GR32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", "||", "SystemZ", "::", "GR64BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "CondCycles", "=", "2", ";", "TrueCycles", "=", "2", ";", "FalseCycles", "=", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "possible", "to", "insert", "a", "select", "instruction", "that", "chooses", "between", "TrueReg", "and", "FalseReg", "based", "on", "the", "condition", "code", "in", "Cond", "." ]

[ "SystemZ", "SystemZ", "2", "SystemZ::GRX32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR64BitRegClass", "2", "2", "2" ]

[]

[ "<s>", "void", "Z80DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "SDLoc", "DL", "(", "Node", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "Node", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "SelectCode", "(", "Node", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"Selecting: \"", "\"== \"", "1" ]

[]

[ "<s>", "void", "MipsAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MipsTargetStreamer", "&", "TS", "=", "getTargetStreamer", "(", ")", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "TS", ".", "forbidModuleDirective", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "isDebugLabel", "(", ")", ")", "return", ";", "if", "(", "InConstantPool", "&&", "Opc", "!=", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegionEnd", ")", ";", "InConstantPool", "=", "false", ";", "}", "if", "(", "Opc", "==", "Mips", "::", "CONSTPOOL_ENTRY", ")", "{", "unsigned", "LabelId", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "CPIdx", "=", "(", "unsigned", ")", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "if", "(", "!", "InConstantPool", ")", "{", "OutStreamer", "->", "EmitDataRegion", "(", "MCDR_DataRegion", ")", ";", "InConstantPool", "=", "true", ";", "}", "OutStreamer", "->", "EmitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "EmitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "EmitGlobalConstant", "(", "MF", "->", "getDataLayout", "(", ")", ",", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Mips", "::", "PATCHABLE_FUNCTION_ENTER", ":", "LowerPATCHABLE_FUNCTION_ENTER", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_FUNCTION_EXIT", ":", "LowerPATCHABLE_FUNCTION_EXIT", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_TAIL_CALL", ":", "LowerPATCHABLE_TAIL_CALL", "(", "*", "MI", ")", ";", "return", ";", "}", "if", "(", "EmitJalrReloc", "&&", "(", "MI", "->", "isReturn", "(", ")", "||", "MI", "->", "isCall", "(", ")", "||", "MI", "->", "isIndirectBranch", "(", ")", ")", ")", "{", "emitDirectiveRelocJalr", "(", "*", "MI", ",", "OutContext", ",", "TM", ",", "*", "OutStreamer", ",", "*", "Subtarget", ")", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "isBundle", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG64", ")", "{", "emitPseudoIndirectBranch", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "\"Pseudo opcode found in EmitInstruction()\"", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "&", "*", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0", ")", ";", "}", "while", "(", "(", "++", "I", "!=", "E", ")", "&&", "I", "->", "isInsideBundle", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "128", "Mips::CONSTPOOL_ENTRY", "Mips::CONSTPOOL_ENTRY", "0", "1", "Mips::PATCHABLE_FUNCTION_ENTER", "Mips::PATCHABLE_FUNCTION_EXIT", "Mips::PATCHABLE_TAIL_CALL", "Mips::PseudoReturn", "Mips::PseudoReturn64", "Mips::PseudoIndirectBranch", "Mips::PseudoIndirectBranch64", "Mips::TAILCALLREG", "Mips::TAILCALLREG64", "Mips", "\"Pseudo opcode found in EmitInstruction()\"" ]

[]

[ "<s>", "bool", "AArch64CollectLOH", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "const", "MachineDominatorTree", "*", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MapRegToId", "RegToId", ";", "MapIdToReg", "IdToReg", ";", "AArch64FunctionInfo", "*", "AArch64FI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "assert", "(", "AArch64FI", "&&", "\"No MachineFunctionInfo for this function!\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Looking for LOH in \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "collectInvolvedReg", "(", "MF", ",", "RegToId", ",", "IdToReg", ",", "TRI", ")", ";", "if", "(", "RegToId", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "DummyOp", "=", "nullptr", ";", "if", "(", "BasicBlockScopeOnly", ")", "{", "const", "AArch64InstrInfo", "*", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "DummyOp", "=", "MF", ".", "CreateMachineInstr", "(", "TII", "->", "get", "(", "AArch64", "::", "COPY", ")", ",", "DebugLoc", "(", ")", ")", ";", "}", "unsigned", "NbReg", "=", "RegToId", ".", "size", "(", ")", ";", "bool", "Modified", "=", "false", ";", "InstrToInstrs", "*", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"ADRP reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "ADRPToReachingDefs", ";", "reachedUsesToDefs", "(", "ADRPToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "true", ")", ";", "computeADRP", "(", "ADRPToReachingDefs", ",", "*", "AArch64FI", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "ColorOpToReachedUses", "=", "new", "InstrToInstrs", "[", "NbReg", "]", ";", "reachingDef", "(", "MF", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ",", "DummyOp", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"All reaching defs\\n\"", ")", ";", "DEBUG", "(", "printReachingDef", "(", "ColorOpToReachedUses", ",", "NbReg", ",", "TRI", ",", "IdToReg", ")", ")", ";", "InstrToInstrs", "UsesToReachingDefs", ";", "reachedUsesToDefs", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "RegToId", ",", "false", ")", ";", "computeOthers", "(", "UsesToReachingDefs", ",", "ColorOpToReachedUses", ",", "*", "AArch64FI", ",", "RegToId", ",", "MDT", ")", ";", "delete", "[", "]", "ColorOpToReachedUses", ";", "if", "(", "BasicBlockScopeOnly", ")", "MF", ".", "DeleteMachineInstr", "(", "DummyOp", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "\"No MachineFunctionInfo for this function!\"", "\"Looking for LOH in \"", "AArch64", "AArch64", "AArch64::COPY", "\"ADRP reaching defs\\n\"", "AArch64", "\"All reaching defs\\n\"", "AArch64" ]

[]

[ "<s>", "void", "NVPTXRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "NVPTX", "::", "VRFrame", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "\"Unexpected\"", "1", "NVPTX::VRFrame", "1" ]

[]

[ "<s>", "void", "ARMConstantIslands", "::", "verify", "(", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "MF", "->", "begin", "(", ")", ",", "E", "=", "MF", "->", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBI", ";", "unsigned", "Align", "=", "MBB", "->", "getAlignment", "(", ")", ";", "unsigned", "MBBId", "=", "MBB", "->", "getNumber", "(", ")", ";", "assert", "(", "BBInfo", "[", "MBBId", "]", ".", "Offset", "%", "(", "1u", "<<", "Align", ")", "==", "0", ")", ";", "assert", "(", "!", "MBBId", "||", "BBInfo", "[", "MBBId", "-", "1", "]", ".", "postOffset", "(", ")", "<=", "BBInfo", "[", "MBBId", "]", ".", "Offset", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Verifying \"", "<<", "CPUsers", ".", "size", "(", ")", "<<", "\" CP users.\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CPUser", "&", "U", "=", "CPUsers", "[", "i", "]", ";", "unsigned", "UserOffset", "=", "getUserOffset", "(", "U", ")", ";", "if", "(", "isCPEntryInRange", "(", "U", ".", "MI", ",", "UserOffset", ",", "U", ".", "CPEMI", ",", "U", ".", "getMaxDisp", "(", ")", "+", "2", ",", "U", ".", "NegOk", ",", "true", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"OK\\n\"", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Out of range.\\n\"", ")", ";", "dumpBBs", "(", ")", ";", "DEBUG", "(", "MF", "->", "dump", "(", ")", ")", ";", "llvm_unreachable", "(", "\"Constant pool entry out of range!\"", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

[ "ARM", "ARM", "1u", "0", "1", "\"Verifying \"", "\" CP users.\\n\"", "0", "2", "\"OK\\n\"", "\"Out of range.\\n\"", "\"Constant pool entry out of range!\"" ]

[]

[ "<s>", "BitVector", "VERegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "Register", "ReservedRegs", "[", "]", "=", "{", "VE", "::", "SX8", ",", "VE", "::", "SX9", ",", "VE", "::", "SX10", ",", "VE", "::", "SX11", ",", "VE", "::", "SX12", ",", "VE", "::", "SX13", ",", "VE", "::", "SX14", ",", "VE", "::", "SX15", ",", "VE", "::", "SX16", ",", "VE", "::", "SX17", ",", "}", ";", "for", "(", "auto", "R", ":", "ReservedRegs", ")", "for", "(", "MCRegAliasIterator", "ItAlias", "(", "R", ",", "this", ",", "true", ")", ";", "ItAlias", ".", "isValid", "(", ")", ";", "++", "ItAlias", ")", "Reserved", ".", "set", "(", "*", "ItAlias", ")", ";", "Reserved", ".", "set", "(", "VE", "::", "VM0", ")", ";", "Reserved", ".", "set", "(", "VE", "::", "VMP0", ")", ";", "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", "." ]

[ "VE", "VE", "VE::SX8", "VE::SX9", "VE::SX10", "VE::SX11", "VE::SX12", "VE::SX13", "VE::SX14", "VE::SX15", "VE::SX16", "VE::SX17", "VE::VM0", "VE::VMP0" ]

[]

[ "<s>", "bool", "dominates", "(", "const", "Waitcnt", "&", "Other", ")", "const", "{", "return", "VmCnt", "<=", "Other", ".", "VmCnt", "&&", "ExpCnt", "<=", "Other", ".", "ExpCnt", "&&", "LgkmCnt", "<=", "Other", ".", "LgkmCnt", ";", "}", "</s>" ]

[ "Returns", "true", "if", "B1", "occurs", "before", "B2", "in", "the", "trace", ",", "or", "if", "it", "is", "the", "same", "block", "as", "B2", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "FixupSFBPass", "::", "buildCopy", "(", "MachineInstr", "*", "LoadInst", ",", "unsigned", "NLoadOpcode", ",", "int64_t", "LoadDisp", ",", "MachineInstr", "*", "StoreInst", ",", "unsigned", "NStoreOpcode", ",", "int64_t", "StoreDisp", ",", "unsigned", "Size", ",", "int64_t", "LMMOffset", ",", "int64_t", "SMMOffset", ")", "{", "MachineOperand", "&", "LoadBase", "=", "getBaseOperand", "(", "LoadInst", ")", ";", "MachineOperand", "&", "StoreBase", "=", "getBaseOperand", "(", "StoreInst", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "LoadInst", "->", "getParent", "(", ")", ";", "MachineMemOperand", "*", "LMMO", "=", "*", "LoadInst", "->", "memoperands_begin", "(", ")", ";", "MachineMemOperand", "*", "SMMO", "=", "*", "StoreInst", "->", "memoperands_begin", "(", ")", ";", "unsigned", "Reg1", "=", "MRI", "->", "createVirtualRegister", "(", "TII", "->", "getRegClass", "(", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "0", ",", "TRI", ",", "*", "(", "MBB", "->", "getParent", "(", ")", ")", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "LoadInst", ",", "LoadInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NLoadOpcode", ")", ",", "Reg1", ")", ".", "add", "(", "LoadBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "LoadDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "LMMO", ",", "LMMOffset", ",", "Size", ")", ")", ";", "DEBUG", "(", "LoadInst", "->", "getPrevNode", "(", ")", "->", "dump", "(", ")", ")", ";", "MachineInstr", "*", "StInst", "=", "StoreInst", ";", "if", "(", "StoreInst", "->", "getPrevNode", "(", ")", "==", "LoadInst", ")", "StInst", "=", "LoadInst", ";", "BuildMI", "(", "*", "MBB", ",", "StInst", ",", "StInst", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "NStoreOpcode", ")", ")", ".", "add", "(", "StoreBase", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addImm", "(", "StoreDisp", ")", ".", "addReg", "(", "X86", "::", "NoRegister", ")", ".", "addReg", "(", "Reg1", ")", ".", "addMemOperand", "(", "MBB", "->", "getParent", "(", ")", "->", "getMachineMemOperand", "(", "SMMO", ",", "SMMOffset", ",", "Size", ")", ")", ";", "DEBUG", "(", "StInst", "->", "getPrevNode", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "Res", "=", "COPY", "Op", "." ]

[ "X86", "0", "1", "X86::NoRegister", "X86::NoRegister", "1", "X86::NoRegister", "X86::NoRegister" ]

[]

[ "<s>", "static", "inline", "bool", "is_float128_p", "(", "tree", "t", ")", "{", "return", "(", "t", "==", "float128_type_node", "||", "(", "t", "&&", "t", "==", "float128t_type_node", ")", "||", "(", "TARGET_IEEEQUAD", "&&", "TARGET_LONG_DOUBLE_128", "&&", "t", "==", "long_double_type_node", ")", ")", ";", "}", "</s>" ]

[ "Check", "whether", "the", "type", "of", "an", "argument", ",", "T", ",", "is", "compatible", "with", "a", "type", "ID", "stored", "into", "a", "struct", "altivec_builtin_types", ".", "Integer", "types", "are", "considered", "compatible", ";", "otherwise", ",", "the", "language", "hook", "lang_hooks.types_compatible_p", "makes", "the", "decision", ".", "Also", "allow", "long", "double", "and", "_Float128", "to", "be", "compatible", "if", "-mabi=ieeelongdouble", "." ]

[ "rs6000" ]

[]

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

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

[ "SIC" ]

[]

[ "<s>", "const", "char", "*", "X86TargetLowering", "::", "LowerXConstraint", "(", "EVT", "ConstraintVT", ")", "const", "{", "if", "(", "ConstraintVT", ".", "isFloatingPoint", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasSSE2", "(", ")", ")", "return", "\"Y\"", ";", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", ")", "return", "\"x\"", ";", "}", "return", "TargetLowering", "::", "LowerXConstraint", "(", "ConstraintVT", ")", ";", "}", "</s>" ]

[ "Try", "to", "replace", "an", "X", "constraint", ",", "which", "matches", "anything", ",", "with", "another", "that", "has", "more", "specific", "requirements", "based", "on", "the", "type", "of", "the", "corresponding", "operand", "." ]

[ "X86", "X86", "\"Y\"", "\"x\"" ]

[]

[ "<s>", "bool", "sh_insn_operands_modified_between_p", "(", "rtx_insn", "*", "operands_insn", ",", "const", "rtx_insn", "*", "from", ",", "const", "rtx_insn", "*", "to", ")", "{", "rtx", "s", "=", "single_set", "(", "operands_insn", ")", ";", "if", "(", "s", "==", "NULL_RTX", ")", "return", "true", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "i", ",", "array", ",", "SET_SRC", "(", "s", ")", ",", "ALL", ")", "if", "(", "*", "i", "!=", "NULL", "&&", "(", "(", "REG_P", "(", "*", "i", ")", "||", "SUBREG_P", "(", "*", "i", ")", ")", "&&", "reg_set_between_p", "(", "*", "i", ",", "from", ",", "to", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "register", "operands", "of", "the", "specified", "insn", "are", "modified", "between", "the", "specified", "from", "and", "to", "insns", "(", "exclusive", "of", "those", "two", ")", "." ]

[ "sh" ]

[]

[ "<s>", "static", "void", "visium_function_arg_advance", "(", "cumulative_args_t", "pcum_v", ",", "enum", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "bool", "named", ")", "{", "int", "size", "=", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "int", "stack_size", "=", "0", ";", "CUMULATIVE_ARGS", "*", "ca", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "if", "(", "TARGET_FPU", "&&", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", "||", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", "*", "2", ")", ")", ")", "{", "if", "(", "ca", "->", "frcount", "+", "size", "<=", "MAX_ARGS_IN_FP_REGISTERS", ")", "ca", "->", "frcount", "+=", "size", ";", "else", "{", "stack_size", "=", "size", ";", "ca", "->", "frcount", "=", "MAX_ARGS_IN_FP_REGISTERS", ";", "}", "}", "else", "{", "if", "(", "ca", "->", "grcount", "+", "size", "<=", "MAX_ARGS_IN_GP_REGISTERS", ")", "ca", "->", "grcount", "+=", "size", ";", "else", "{", "stack_size", "=", "size", ";", "ca", "->", "grcount", "=", "MAX_ARGS_IN_GP_REGISTERS", ";", "}", "}", "if", "(", "named", ")", "ca", "->", "stack_words", "+=", "stack_size", ";", "}", "</s>" ]

[ "Update", "the", "summarizer", "variable", "pointed", "to", "by", "PCUM_V", "to", "advance", "past", "an", "argument", "in", "the", "argument", "list", ".", "The", "values", "MODE", ",", "TYPE", "and", "NAMED", "describe", "that", "argument", ".", "Once", "this", "is", "done", ",", "the", "variable", "CUM", "is", "suitable", "for", "analyzing", "the", "_following_", "argument", "with", "visium_function_arg", "." ]

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

[]

[ "<s>", "bool", "PPCCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "return", "VRegs", ".", "empty", "(", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "scalar_chain", "::", "convert_reg", "(", "unsigned", "regno", ")", "{", "bool", "scalar_copy", "=", "bitmap_bit_p", "(", "defs_conv", ",", "regno", ")", ";", "rtx", "reg", "=", "regno_reg_rtx", "[", "regno", "]", ";", "rtx", "scopy", "=", "NULL_RTX", ";", "df_ref", "ref", ";", "bitmap", "conv", ";", "conv", "=", "BITMAP_ALLOC", "(", "NULL", ")", ";", "bitmap_copy", "(", "conv", ",", "insns", ")", ";", "if", "(", "scalar_copy", ")", "scopy", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "for", "(", "ref", "=", "DF_REG_DEF_CHAIN", "(", "regno", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "{", "rtx_insn", "*", "insn", "=", "DF_REF_INSN", "(", "ref", ")", ";", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "reg", "=", "DF_REF_REG", "(", "ref", ")", ";", "if", "(", "!", "MEM_P", "(", "src", ")", ")", "{", "replace_with_subreg_in_insn", "(", "insn", ",", "reg", ",", "reg", ")", ";", "bitmap_clear_bit", "(", "conv", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "if", "(", "scalar_copy", ")", "{", "rtx", "vcopy", "=", "gen_reg_rtx", "(", "V2DImode", ")", ";", "start_sequence", "(", ")", ";", "if", "(", "TARGET_INTER_UNIT_MOVES_FROM_VEC", ")", "{", "emit_move_insn", "(", "vcopy", ",", "gen_rtx_SUBREG", "(", "V2DImode", ",", "reg", ",", "0", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "scopy", ",", "0", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "vcopy", ",", "0", ")", ")", ";", "emit_move_insn", "(", "vcopy", ",", "gen_rtx_LSHIFTRT", "(", "V2DImode", ",", "vcopy", ",", "GEN_INT", "(", "32", ")", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "scopy", ",", "4", ")", ",", "gen_rtx_SUBREG", "(", "SImode", ",", "vcopy", ",", "0", ")", ")", ";", "}", "else", "{", "rtx", "tmp", "=", "assign_386_stack_local", "(", "DImode", ",", "SLOT_TEMP", ")", ";", "emit_move_insn", "(", "tmp", ",", "reg", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "scopy", ",", "0", ")", ",", "adjust_address", "(", "tmp", ",", "SImode", ",", "0", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_SUBREG", "(", "SImode", ",", "scopy", ",", "4", ")", ",", "adjust_address", "(", "tmp", ",", "SImode", ",", "4", ")", ")", ";", "}", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_conversion_insns", "(", "seq", ",", "insn", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Copied r%d to a scalar register r%d for insn %d\\n\"", ",", "regno", ",", "REGNO", "(", "scopy", ")", ",", "INSN_UID", "(", "insn", ")", ")", ";", "}", "}", "for", "(", "ref", "=", "DF_REG_USE_CHAIN", "(", "regno", ")", ";", "ref", ";", "ref", "=", "DF_REF_NEXT_REG", "(", "ref", ")", ")", "if", "(", "bitmap_bit_p", "(", "insns", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", "{", "if", "(", "bitmap_bit_p", "(", "conv", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ")", "{", "rtx", "def_set", "=", "single_set", "(", "DF_REF_INSN", "(", "ref", ")", ")", ";", "if", "(", "!", "MEM_P", "(", "SET_DEST", "(", "def_set", ")", ")", "||", "!", "REG_P", "(", "SET_SRC", "(", "def_set", ")", ")", ")", "replace_with_subreg_in_insn", "(", "DF_REF_INSN", "(", "ref", ")", ",", "reg", ",", "reg", ")", ";", "bitmap_clear_bit", "(", "conv", ",", "DF_REF_INSN_UID", "(", "ref", ")", ")", ";", "}", "}", "else", "if", "(", "DF_REF_CHAIN", "(", "ref", ")", "&&", "NONDEBUG_INSN_P", "(", "DF_REF_INSN", "(", "ref", ")", ")", ")", "{", "gcc_assert", "(", "scopy", ")", ";", "replace_rtx", "(", "DF_REF_INSN", "(", "ref", ")", ",", "reg", ",", "scopy", ")", ";", "df_insn_rescan", "(", "DF_REF_INSN", "(", "ref", ")", ")", ";", "}", "BITMAP_FREE", "(", "conv", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "std", "::", "vector", "<", "std", "::", "pair", "<", "uint64_t", ",", "uint64_t", ">>", "findPltEntries", "(", "uint64_t", "PltSectionVA", ",", "ArrayRef", "<", "uint8_t", ">", "PltContents", ",", "uint64_t", "GotPltSectionVA", ",", "const", "Triple", "&", "TargetTriple", ")", "const", "override", "{", "std", "::", "vector", "<", "std", "::", "pair", "<", "uint64_t", ",", "uint64_t", ">>", "Result", ";", "for", "(", "uint64_t", "Byte", "=", "0", ",", "End", "=", "PltContents", ".", "size", "(", ")", ";", "Byte", "+", "7", "<", "End", ";", "Byte", "+=", "4", ")", "{", "uint32_t", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "PltContents", ".", "data", "(", ")", "+", "Byte", ")", ";", "uint64_t", "Off", "=", "0", ";", "if", "(", "Insn", "==", "0xd503245f", ")", "{", "Off", "=", "4", ";", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "PltContents", ".", "data", "(", ")", "+", "Byte", "+", "Off", ")", ";", "}", "if", "(", "(", "Insn", "&", "0x9f000000", ")", "!=", "0x90000000", ")", "continue", ";", "Off", "+=", "4", ";", "uint64_t", "Imm", "=", "(", "(", "(", "PltSectionVA", "+", "Byte", ")", ">>", "12", ")", "<<", "12", ")", "+", "(", "(", "(", "Insn", ">>", "29", ")", "&", "3", ")", "<<", "12", ")", "+", "(", "(", "(", "Insn", ">>", "5", ")", "&", "0x3ffff", ")", "<<", "14", ")", ";", "uint32_t", "Insn2", "=", "support", "::", "endian", "::", "read32le", "(", "PltContents", ".", "data", "(", ")", "+", "Byte", "+", "Off", ")", ";", "if", "(", "Insn2", ">>", "22", "==", "0x3e5", ")", "{", "Imm", "+=", "(", "(", "Insn2", ">>", "10", ")", "&", "0xfff", ")", "<<", "3", ";", "Result", ".", "push_back", "(", "std", "::", "make_pair", "(", "PltSectionVA", "+", "Byte", ",", "Imm", ")", ")", ";", "Byte", "+=", "4", ";", "}", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "(", "PLT", "virtual", "address", ",", "GOT", "virtual", "address", ")", "pairs", "for", "PLT", "entries", "." ]

[ "AArch64", "0", "7", "4", "support::endian", "0", "0xd503245f", "4", "support::endian", "0x9f000000", "0x90000000", "4", "12", "12", "29", "3", "12", "5", "0x3ffff", "14", "support::endian", "22", "0x3e5", "10", "0xfff", "3", "4" ]

[]

[ "<s>", "void", "Z80InstPrinterBase", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "markup", "(", "\"<reg:\"", ")", "<<", "getRegName", "(", "RegNo", ")", "<<", "markup", "(", "\">\"", ")", ";", "}", "</s>" ]

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

[ "Z80", "Z80", "\"<reg:\"", "\">\"" ]

[]

[ "<s>", "void", "pdp11_expand_epilogue", "(", "void", ")", "{", "HOST_WIDE_INT", "fsize", "=", "get_frame_size", "(", ")", ";", "unsigned", "regno", ";", "rtx", "x", ",", "reg", ",", "via_ac", "=", "NULL", ";", "if", "(", "pdp11_saved_regno", "(", "AC4_REGNUM", ")", "||", "pdp11_saved_regno", "(", "AC5_REGNUM", ")", ")", "{", "for", "(", "regno", "=", "AC0_REGNUM", ";", "regno", "<=", "AC3_REGNUM", ";", "regno", "++", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "via_ac", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "break", ";", "}", "}", "if", "(", "!", "frame_pointer_needed", "||", "crtl", "->", "sp_is_unchanging", ")", "{", "for", "(", "regno", "=", "AC5_REGNUM", ";", "regno", ">=", "AC0_REGNUM", ";", "regno", "--", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "x", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "DFmode", ",", "x", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "if", "(", "LOAD_FPU_REG_P", "(", "regno", ")", ")", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "else", "{", "emit_move_insn", "(", "via_ac", ",", "x", ")", ";", "emit_move_insn", "(", "reg", ",", "via_ac", ")", ";", "}", "}", "for", "(", "regno", "=", "PC_REGNUM", ";", "regno", ">=", "R0_REGNUM", "+", "2", ";", "regno", "--", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", "&&", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", ")", "{", "x", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "x", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ",", "x", ")", ";", "}", "}", "else", "{", "HOST_WIDE_INT", "ofs", "=", "-", "pdp11_sp_frame_offset", "(", ")", ";", "for", "(", "regno", "=", "AC5_REGNUM", ";", "regno", ">=", "AC0_REGNUM", ";", "regno", "--", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", ")", "{", "x", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "ofs", ")", ";", "x", "=", "gen_frame_mem", "(", "DFmode", ",", "x", ")", ";", "reg", "=", "gen_rtx_REG", "(", "DFmode", ",", "regno", ")", ";", "if", "(", "LOAD_FPU_REG_P", "(", "regno", ")", ")", "emit_move_insn", "(", "reg", ",", "x", ")", ";", "else", "{", "emit_move_insn", "(", "via_ac", ",", "x", ")", ";", "emit_move_insn", "(", "reg", ",", "via_ac", ")", ";", "}", "ofs", "+=", "8", ";", "}", "for", "(", "regno", "=", "PC_REGNUM", ";", "regno", ">=", "R0_REGNUM", "+", "2", ";", "regno", "--", ")", "if", "(", "pdp11_saved_regno", "(", "regno", ")", "&&", "(", "regno", "!=", "HARD_FRAME_POINTER_REGNUM", "||", "!", "frame_pointer_needed", ")", ")", "{", "x", "=", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "ofs", ")", ";", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "x", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ",", "x", ")", ";", "ofs", "+=", "2", ";", "}", "}", "if", "(", "fsize", ")", "{", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "frame_pointer_needed", ")", "{", "emit_move_insn", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "}", "else", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "fsize", ")", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "x", "=", "gen_rtx_POST_INC", "(", "Pmode", ",", "stack_pointer_rtx", ")", ";", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "x", ")", ";", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "x", ")", ";", "}", "emit_jump_insn", "(", "gen_return", "(", ")", ")", ";", "}", "</s>" ]

[ "Generate", "epilogue", ".", "This", "uses", "the", "frame", "pointer", "to", "pop", "the", "local", "variables", "and", "any", "alloca", "data", "off", "the", "stack", ".", "If", "there", "is", "no", "alloca", "and", "frame", "pointer", "elimination", "has", "n't", "been", "disabled", ",", "there", "is", "no", "frame", "pointer", "and", "the", "local", "variables", "are", "popped", "by", "adjusting", "the", "stack", "pointer", "instead", "." ]

[ "pdp11", "2", "8", "2", "2" ]

[]

[ "<s>", "void", "TGSIMCInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "mi", ",", "raw_ostream", "&", "os", ",", "StringRef", "annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "mi", ",", "os", ")", ";", "printAnnotation", "(", "os", ",", "annot", ")", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI" ]

[]

[ "<s>", "static", "void", "aarch64_define_unconditional_macros", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "\"__aarch64__\"", ")", ";", "builtin_define", "(", "\"__ARM_64BIT_STATE\"", ")", ";", "builtin_define", "(", "\"__ARM_ARCH_ISA_A64\"", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ALIGN_MAX_PWR\"", ",", "28", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ALIGN_MAX_STACK_PWR\"", ",", "16", ")", ";", "builtin_define", "(", "\"__ARM_ARCH_8A\"", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ARCH_PROFILE\"", ",", "'A'", ")", ";", "builtin_define", "(", "\"__ARM_FEATURE_CLZ\"", ")", ";", "builtin_define", "(", "\"__ARM_FEATURE_IDIV\"", ")", ";", "builtin_define", "(", "\"__ARM_FEATURE_UNALIGNED\"", ")", ";", "builtin_define", "(", "\"__ARM_PCS_AAPCS64\"", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_SIZEOF_WCHAR_T\"", ",", "WCHAR_TYPE_SIZE", "/", "8", ")", ";", "}", "</s>" ]

[ "Define", "the", "macros", "that", "we", "always", "expect", "to", "have", "on", "AArch64", "." ]

[ "aarch64", "\"__aarch64__\"", "\"__ARM_64BIT_STATE\"", "\"__ARM_ARCH_ISA_A64\"", "\"__ARM_ALIGN_MAX_PWR\"", "28", "\"__ARM_ALIGN_MAX_STACK_PWR\"", "16", "\"__ARM_ARCH_8A\"", "\"__ARM_ARCH_PROFILE\"", "\"__ARM_FEATURE_CLZ\"", "\"__ARM_FEATURE_IDIV\"", "\"__ARM_FEATURE_UNALIGNED\"", "\"__ARM_PCS_AAPCS64\"", "\"__ARM_SIZEOF_WCHAR_T\"", "8" ]

[]

[ "<s>", "unsigned", "ARCInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "dl", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"Code size not handled.\"", ")", ";", "assert", "(", "TBB", "&&", "\"insertBranch must not be told to insert a fallthrough\"", ")", ";", "assert", "(", "(", "Cond", ".", "size", "(", ")", "==", "3", "||", "Cond", ".", "size", "(", ")", "==", "0", ")", "&&", "\"ARC branch conditions have two components!\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "ARC", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "int", "BccOpc", "=", "Cond", "[", "1", "]", ".", "isImm", "(", ")", "?", "ARC", "::", "BRcc_ru6_p", ":", "ARC", "::", "BRcc_rr_p", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "BccOpc", ")", ")", ";", "MIB", ".", "addMBB", "(", "TBB", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "MIB", ".", "add", "(", "Cond", "[", "i", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "{", "return", "1", ";", "}", "BuildMI", "(", "&", "MBB", ",", "dl", ",", "get", "(", "ARC", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Code size not handled.\"", "\"insertBranch must not be told to insert a fallthrough\"", "3", "0", "\"ARC branch conditions have two components!\"", "ARC::BR", "1", "1", "ARC::BRcc_ru6_p", "ARC::BRcc_rr_p", "0", "3", "1", "ARC::BR", "2" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_PPC", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "Arg", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "Arg", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "dl", ",", "VA", ".", "getLocVT", "(", ")", ",", "Arg", ")", ";", "break", ";", "}", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "Arg", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addILPOpts", "(", ")", "{", "if", "(", "EnableCondOpt", ")", "addPass", "(", "createAArch64ConditionOptimizerPass", "(", ")", ")", ";", "if", "(", "EnableCCMP", ")", "addPass", "(", "createAArch64ConditionalCompares", "(", ")", ")", ";", "if", "(", "EnableMCR", ")", "addPass", "(", "&", "MachineCombinerID", ")", ";", "if", "(", "EnableCondBrTuning", ")", "addPass", "(", "createAArch64CondBrTuning", "(", ")", ")", ";", "if", "(", "EnableEarlyIfConversion", ")", "addPass", "(", "&", "EarlyIfConverterID", ")", ";", "if", "(", "EnableStPairSuppress", ")", "addPass", "(", "createAArch64StorePairSuppressPass", "(", ")", ")", ";", "addPass", "(", "createAArch64SIMDInstrOptPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createAArch64StackTaggingPreRAPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Add", "passes", "that", "optimize", "instruction", "level", "parallelism", "for", "out-of-order", "targets", "." ]

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

[]

[ "<s>", "void", "WebAssemblyAsmPrinter", "::", "emitLinkage", "(", "const", "GlobalValue", "*", "GV", ",", "MCSymbol", "*", "Sym", ")", "const", "{", "AsmPrinter", "::", "emitLinkage", "(", "GV", ",", "Sym", ")", ";", "const_cast", "<", "WebAssemblyAsmPrinter", "*", ">", "(", "this", ")", "->", "emitExternalDecls", "(", "*", "MMI", "->", "getModule", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "emits", "linkage", "information", "about", "GVSym", "based", "on", "GV", ",", "if", "this", "is", "supported", "by", "the", "target", "." ]

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

[]

[ "<s>", "static", "bool", "tilegx_legitimate_constant_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "return", "!", "tilegx_tls_referenced_p", "(", "x", ")", ";", "default", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_CONSTANT_P", ".", "This", "is", "all", "constants", "for", "which", "we", "are", "willing", "to", "load", "the", "value", "into", "a", "register", "via", "a", "move", "pattern", ".", "TLS", "can", "not", "be", "treated", "as", "a", "constant", "because", "it", "can", "include", "a", "function", "call", "." ]

[ "tilegx" ]

[]

[ "<s>", "static", "bool", "ix86_cannot_force_const_mem", "(", "rtx", "x", ")", "{", "return", "!", "legitimate_constant_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Determine", "if", "it", "'s", "legal", "to", "put", "X", "into", "the", "constant", "pool", ".", "This", "is", "not", "possible", "for", "the", "address", "of", "thread-local", "symbols", ",", "which", "is", "checked", "above", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "nios2_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "op", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "CONST", ":", "case", "CONST_INT", ":", "case", "LABEL_REF", ":", "case", "CONST_DOUBLE", ":", "case", "SYMBOL_REF", ":", "if", "(", "gprel_constant_p", "(", "op", ")", ")", "{", "fprintf", "(", "file", ",", "\"%%gprel(\"", ")", ";", "output_addr_const", "(", "file", ",", "op", ")", ";", "fprintf", "(", "file", ",", "\")(%s)\"", ",", "reg_names", "[", "GP_REGNO", "]", ")", ";", "return", ";", "}", "break", ";", "case", "PLUS", ":", "{", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "REG_P", "(", "op0", ")", "&&", "CONSTANT_P", "(", "op1", ")", ")", "{", "output_addr_const", "(", "file", ",", "op1", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "op0", ")", "]", ")", ";", "return", ";", "}", "else", "if", "(", "REG_P", "(", "op1", ")", "&&", "CONSTANT_P", "(", "op0", ")", ")", "{", "output_addr_const", "(", "file", ",", "op0", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "op1", ")", "]", ")", ";", "return", ";", "}", "}", "break", ";", "case", "REG", ":", "fprintf", "(", "file", ",", "\"0(%s)\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "{", "rtx", "base", "=", "XEXP", "(", "op", ",", "0", ")", ";", "nios2_print_operand_address", "(", "file", ",", "base", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "fprintf", "(", "stderr", ",", "\"Missing way to print address\\n\"", ")", ";", "debug_rtx", "(", "op", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "nios2", "\"%%gprel(\"", "\")(%s)\"", "0", "1", "\"(%s)\"", "\"(%s)\"", "\"0(%s)\"", "0", "\"Missing way to print address\\n\"" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addIRPasses", "(", ")", "{", "if", "(", "TM", "->", "Options", ".", "ThreadModel", "==", "ThreadModel", "::", "Single", ")", "addPass", "(", "createLowerAtomicPass", "(", ")", ")", ";", "else", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerGlobalDtors", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixFunctionBitcasts", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyOptimizeReturned", "(", ")", ")", ";", "if", "(", "!", "EnableEmException", ")", "{", "addPass", "(", "createLowerInvokePass", "(", ")", ")", ";", "addPass", "(", "createUnreachableBlockEliminationPass", "(", ")", ")", ";", "}", "if", "(", "EnableEmException", "||", "EnableEmSjLj", ")", "addPass", "(", "createWebAssemblyLowerEmscriptenEHSjLj", "(", "EnableEmException", ",", "EnableEmSjLj", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

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

[]