Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "aarch64_hard_regno_mode_ok", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "regno", "==", "CC_REGNUM", ";", "if", "(", "regno", "==", "SP_REGNUM", ")", "return", "mode", "==", "Pmode", "||", "mode", "==", "ptr_mode", ";", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "mode", "==", "Pmode", ";", "if", "(", "GP_REGNUM_P", "(", "regno", ")", "&&", "!", "aarch64_vect_struct_mode_p", "(", "mode", ")", ")", "return", "1", ";", "if", "(", "FP_REGNUM_P", "(", "regno", ")", ")", "{", "if", "(", "aarch64_vect_struct_mode_p", "(", "mode", ")", ")", "return", "(", "regno", "+", "aarch64_hard_regno_nregs", "(", "regno", ",", "mode", ")", "-", "1", ")", "<=", "V31_REGNUM", ";", "else", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_MODE_OK", "." ]

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

[]

[ "<s>", "void", "ix86_split_xorsign", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", ",", "vmode", ";", "rtx", "dest", ",", "op0", ",", "mask", ",", "x", ";", "dest", "=", "operands", "[", "0", "]", ";", "op0", "=", "operands", "[", "1", "]", ";", "mask", "=", "operands", "[", "3", "]", ";", "mode", "=", "GET_MODE", "(", "dest", ")", ";", "vmode", "=", "GET_MODE", "(", "mask", ")", ";", "dest", "=", "lowpart_subreg", "(", "vmode", ",", "dest", ",", "mode", ")", ";", "x", "=", "gen_rtx_AND", "(", "vmode", ",", "dest", ",", "mask", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "op0", "=", "lowpart_subreg", "(", "vmode", ",", "op0", ",", "mode", ")", ";", "x", "=", "gen_rtx_XOR", "(", "vmode", ",", "dest", ",", "op0", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Deconstruct", "an", "xorsign", "operation", "into", "bit", "masks", "." ]

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

[]

[ "<s>", "SDValue", "OR1KTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_OR1K32", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "if", "(", "RVLocs", "[", "i", "]", ".", "isRegLoc", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", "->", "hasStructRetAttr", "(", ")", ")", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "OR1KMachineFunctionInfo", "*", "OR1KMFI", "=", "MF", ".", "getInfo", "<", "OR1KMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "Reg", "=", "OR1KMFI", "->", "getSRetReturnReg", "(", ")", ";", "assert", "(", "Reg", "&&", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "getPointerTy", "(", ")", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "OR1K", "::", "R11", ",", "Val", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "OR1K", "::", "R11", ")", ";", "}", "unsigned", "Opc", "=", "OR1KISD", "::", "RET_FLAG", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "ISD::OutputArg", "16", "OR1K", "0", "0", "\"Can only return in registers!\"", "1", "OR1K", "OR1K", "OR1K", "OR1K", "\"SRetReturnReg should have been set in LowerFormalArguments().\"", "OR1K::R11", "1", "OR1K::R11", "OR1KISD::RET_FLAG", "MVT::Other", "MVT::Other" ]

[]

[ "<s>", "void", "SystemZPostRASchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "DAG", "=", "dag", ";", "HazardRec", ".", "setDAG", "(", "dag", ")", ";", "HazardRec", ".", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "WebAssemblyAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "ExtraCode", ",", "OS", ")", ")", "return", "false", ";", "if", "(", "!", "ExtraCode", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "case", "MachineOperand", "::", "MO_Immediate", ":", "OS", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_Register", ":", "assert", "(", "MI", "->", "getOpcode", "(", ")", "==", "WebAssembly", "::", "INLINEASM", ")", ";", "OS", "<<", "regToString", "(", "MO", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "PrintSymbolOperand", "(", "MO", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "OS", ")", ";", "return", "false", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", "->", "print", "(", "OS", ",", "MAI", ")", ";", "return", "false", ";", "default", ":", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::INLINEASM" ]

[]

[ "<s>", "bool", "invalidate", "(", "Function", "&", ",", "const", "PreservedAnalyses", "&", ")", "{", "return", "false", ";", "}", "</s>" ]

[ "Handle", "invalidation", "events", "from", "the", "new", "pass", "manager", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "mep_reuse_lo_p", "(", "rtx", "lo", ",", "rtx", "gpr", ",", "rtx_insn", "*", "insn", ",", "bool", "gpr_dead_p", ")", "{", "bool", "result", "=", "mep_reuse_lo_p_1", "(", "lo", ",", "gpr", ",", "insn", ",", "gpr_dead_p", ")", ";", "extract_insn", "(", "insn", ")", ";", "return", "result", ";", "}", "</s>" ]

[ "A", "wrapper", "around", "mep_reuse_lo_p_1", "that", "preserves", "recog_data", "." ]

[ "mep" ]

[]

[ "<s>", "static", "bool", "xtensa_member_type_forces_blk", "(", "const_tree", ",", "machine_mode", "mode", ")", "{", "return", "mode", "==", "CQImode", "||", "mode", "==", "CHImode", ";", "}", "</s>" ]

[ "Disable", "the", "use", "of", "word-sized", "or", "smaller", "complex", "modes", "for", "structures", ",", "and", "for", "function", "arguments", "in", "particular", ",", "where", "they", "cause", "problems", "with", "register", "a7", ".", "The", "xtensa_copy_incoming_a7", "function", "assumes", "that", "there", "is", "a", "single", "reference", "to", "an", "argument", "in", "a7", ",", "but", "with", "small", "complex", "modes", "the", "real", "and", "imaginary", "components", "may", "be", "extracted", "separately", ",", "leading", "to", "two", "uses", "of", "the", "register", ",", "only", "one", "of", "which", "would", "be", "replaced", "." ]

[ "xtensa" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "createPostMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "override", "{", "return", "new", "ScheduleDAGMI", "(", "C", ",", "llvm", "::", "make_unique", "<", "SystemZPostRASchedStrategy", ">", "(", "C", ")", ",", "true", ")", ";", "}", "</s>" ]

[ "Similar", "to", "createMachineScheduler", "but", "used", "when", "postRA", "machine", "scheduling", "is", "enabled", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "TOYDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "llvm_unreachable", "(", "\"SelectInlineAsmMemoryOperand not implemented yet!\\n\"", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "\"SelectInlineAsmMemoryOperand not implemented yet!\\n\"" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "assert", "(", "0", "&&", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "assert", "(", "0", "&&", "\"TLS not implemented for Hexagon.\"", ")", ";", "case", "ISD", "::", "MEMBARRIER", ":", "return", "LowerMEMBARRIER", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Should not custom lower this!\"", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "0", "\"TLS not implemented for Hexagon.\"", "ISD::MEMBARRIER", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::VASTART", "ISD::BR_JT", "ISD::DYNAMIC_STACKALLOC", "ISD::SELECT_CC", "ISD::INTRINSIC_WO_CHAIN", "ISD::INLINEASM" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "uint32_t", "Val", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "EmitByte", "(", "Val", "&", "0xff", ",", "OS", ")", ";", "Val", ">>=", "8", ";", "}", "}", "</s>" ]

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

[ "TeeRISC", "0", "4", "0xff", "8" ]

[]

[ "<s>", "unsigned", "P2InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "&&", "I", "->", "getOpcode", "(", ")", "!=", "P2", "::", "JMPr", "&&", "I", "->", "getOpcode", "(", ")", "!=", "P2", "::", "JMP", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "P2", "P2", "\"code size not handled\"", "0", "P2::JMPr", "P2::JMP" ]

[]

[ "<s>", "void", "ARMConstantPoolValue", "::", "print", "(", "raw_ostream", "&", "O", ")", "const", "{", "if", "(", "CVal", ")", "O", "<<", "CVal", "->", "getName", "(", ")", ";", "else", "O", "<<", "S", ";", "if", "(", "Modifier", ")", "O", "<<", "\"(\"", "<<", "getModifierText", "(", ")", "<<", "\")\"", ";", "if", "(", "PCAdjust", "!=", "0", ")", "{", "O", "<<", "\"-(LPC\"", "<<", "LabelId", "<<", "\"+\"", "<<", "(", "unsigned", ")", "PCAdjust", ";", "if", "(", "AddCurrentAddress", ")", "O", "<<", "\"-.\"", ";", "O", "<<", "\")\"", ";", "}", "}", "</s>" ]

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

[ "ARM", "ARM", "\"(\"", "\")\"", "0", "\"-(LPC\"", "\"+\"", "\"-.\"", "\")\"" ]

[]

[ "<s>", "void", "LC2200InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "LC2200", "::", "GRRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "LC2200", "::", "LW", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "LC2200", "LC2200", "LC2200::GRRegsRegClass", "LC2200::LW", "\"Can't load this register from stack slot\"", "0" ]

[]

[ "<s>", "unsigned", "SPURegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "SPU", "::", "R1", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU::R1" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "K_Token", ":", "OS", "<<", "\"Tok \"", ";", "OS", ".", "write", "(", "Tok", ".", "Data", ",", "Tok", ".", "Length", ")", ";", "break", ";", "case", "K_Register", ":", "OS", "<<", "\"Reg \"", "<<", "Reg", ".", "RegNum", ";", "break", ";", "case", "K_Immediate", ":", "OS", "<<", "\"Imm \"", ";", "OS", "<<", "*", "Imm", ".", "Val", ";", "break", ";", "case", "K_Memory", ":", "OS", "<<", "\"Mem \"", "<<", "Mem", ".", "BaseReg", "<<", "\" \"", ";", "if", "(", "Mem", ".", "Off", ")", "OS", "<<", "*", "Mem", ".", "Off", ";", "else", "OS", "<<", "\"0\"", ";", "break", ";", "}", "}", "</s>" ]

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

[ "Nyuzi", "\"Tok \"", "\"Reg \"", "\"Imm \"", "\"Mem \"", "\" \"", "\"0\"" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "handleD16VData", "(", "SDValue", "VData", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "StoreVT", "=", "VData", ".", "getValueType", "(", ")", ";", "SDLoc", "DL", "(", "VData", ")", ";", "if", "(", "StoreVT", ".", "isVector", "(", ")", ")", "{", "assert", "(", "(", "StoreVT", ".", "getVectorNumElements", "(", ")", "!=", "3", ")", "&&", "\"Handle v3f16\"", ")", ";", "if", "(", "!", "Subtarget", "->", "hasUnpackedD16VMem", "(", ")", ")", "{", "if", "(", "!", "isTypeLegal", "(", "StoreVT", ")", ")", "{", "EVT", "EquivStoreVT", "=", "getEquivalentMemType", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StoreVT", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "EquivStoreVT", ",", "VData", ")", ";", "}", "}", "else", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "EquivStoreVT", "=", "(", "StoreVT", "==", "MVT", "::", "v2f16", ")", "?", "MVT", "::", "v2i32", ":", "MVT", "::", "v4i32", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "EquivStoreVT", ",", "IntVData", ")", ";", "}", "}", "return", "VData", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "SI", "3", "\"Handle v3f16\"", "ISD::BITCAST", "ISD::BITCAST", "MVT::v2f16", "MVT::v2i32", "MVT::v4i32", "ISD::ZERO_EXTEND" ]

[]

[ "<s>", "MachineMemOperand", "::", "Flags", "AArch64TargetLowering", "::", "getTargetMMOFlags", "(", "const", "Instruction", "&", "I", ")", "const", "{", "if", "(", "Subtarget", "->", "getProcFamily", "(", ")", "==", "AArch64Subtarget", "::", "Falkor", "&&", "I", ".", "getMetadata", "(", "FALKOR_STRIDED_ACCESS_MD", ")", "!=", "nullptr", ")", "return", "MOStridedAccess", ";", "return", "MachineMemOperand", "::", "MONone", ";", "}", "</s>" ]

[ "This", "callback", "is", "used", "to", "inspect", "load/store", "instructions", "and", "add", "target-specific", "MachineMemOperand", "flags", "to", "them", "." ]

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

[]

[ "<s>", "unsigned", "SIInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "Register", "PCReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "*", "GetPC", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_GETPC_B64", ")", ",", "PCReg", ")", ";", "auto", "&", "MCCtx", "=", "MF", "->", "getContext", "(", ")", ";", "MCSymbol", "*", "PostGetPCLabel", "=", "MCCtx", ".", "createTempSymbol", "(", "\"post_getpc\"", ",", "true", ")", ";", "GetPC", "->", "setPostInstrSymbol", "(", "*", "MF", ",", "PostGetPCLabel", ")", ";", "MCSymbol", "*", "OffsetLo", "=", "MCCtx", ".", "createTempSymbol", "(", "\"offset_lo\"", ",", "true", ")", ";", "MCSymbol", "*", "OffsetHi", "=", "MCCtx", ".", "createTempSymbol", "(", "\"offset_hi\"", ",", "true", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "PCReg", ",", "0", ",", "AMDGPU", "::", "sub0", ")", ".", "addSym", "(", "OffsetLo", ",", "MO_FAR_BRANCH_OFFSET", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_ADDC_U32", ")", ")", ".", "addReg", "(", "PCReg", ",", "RegState", "::", "Define", ",", "AMDGPU", "::", "sub1", ")", ".", "addReg", "(", "PCReg", ",", "0", ",", "AMDGPU", "::", "sub1", ")", ".", "addSym", "(", "OffsetHi", ",", "MO_FAR_BRANCH_OFFSET", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_SETPC_B64", ")", ")", ".", "addReg", "(", "PCReg", ")", ";", "auto", "ComputeBlockSize", "=", "[", "]", "(", "const", "TargetInstrInfo", "*", "TII", ",", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "unsigned", "Size", "=", "0", ";", "for", "(", "const", "MachineInstr", "&", "MI", ":", "MBB", ")", "Size", "+=", "TII", "->", "getInstSizeInBytes", "(", "MI", ")", ";", "return", "Size", ";", "}", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "Register", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "AMDGPU", "::", "SReg_64RegClass", ",", "MachineBasicBlock", "::", "iterator", "(", "GetPC", ")", ",", "false", ",", "0", ")", ";", "MRI", ".", "replaceRegWith", "(", "PCReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "auto", "*", "Offset", "=", "MCBinaryExpr", "::", "createSub", "(", "MCSymbolRefExpr", "::", "create", "(", "DestBB", ".", "getSymbol", "(", ")", ",", "MCCtx", ")", ",", "MCSymbolRefExpr", "::", "create", "(", "PostGetPCLabel", ",", "MCCtx", ")", ",", "MCCtx", ")", ";", "auto", "*", "Mask", "=", "MCConstantExpr", "::", "create", "(", "0xFFFFFFFFULL", ",", "MCCtx", ")", ";", "OffsetLo", "->", "setVariableValue", "(", "MCBinaryExpr", "::", "createAnd", "(", "Offset", ",", "Mask", ",", "MCCtx", ")", ")", ";", "auto", "*", "ShAmt", "=", "MCConstantExpr", "::", "create", "(", "32", ",", "MCCtx", ")", ";", "OffsetHi", "->", "setVariableValue", "(", "MCBinaryExpr", "::", "createAShr", "(", "Offset", ",", "ShAmt", ",", "MCCtx", ")", ")", ";", "return", "ComputeBlockSize", "(", "this", ",", "MBB", ")", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "AMDGPU", "SI", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "AMDGPU::SReg_64RegClass", "AMDGPU::S_GETPC_B64", "\"post_getpc\"", "\"offset_lo\"", "\"offset_hi\"", "AMDGPU::S_ADD_U32", "AMDGPU::sub0", "0", "AMDGPU::sub0", "AMDGPU::S_ADDC_U32", "AMDGPU::sub1", "0", "AMDGPU::sub1", "AMDGPU::S_SETPC_B64", "0", "AMDGPU::SReg_64RegClass", "0", "0xFFFFFFFFULL", "32" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", "->", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "isVALU", "(", "*", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "DefinedRC", "->", "getSize", "(", ")", ")", ")", "{", "unsigned", "SGPRUsed", "=", "MO", "->", "isReg", "(", ")", "?", "MO", "->", "getReg", "(", ")", ":", "(", "unsigned", ")", "AMDGPU", "::", "NoRegister", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "==", "OpIdx", ")", "continue", ";", "const", "MachineOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "getReg", "(", ")", "!=", "SGPRUsed", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "getOpSize", "(", "*", "MI", ",", "i", ")", ")", ")", "{", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "*", "MO", ")", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", ")", ";", "if", "(", "!", "DefinedRC", ")", "{", "return", "true", ";", "}", "return", "isImmOperandLegal", "(", "MI", ",", "OpIdx", ",", "*", "MO", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "is", "a", "legal", "operand", "if", "it", "was", "the", "OpIdx", "Operand", "for", "MI", "." ]

[ "AMDGPU", "SI", "1", "AMDGPU::NoRegister", "0" ]

[]

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

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

[ "SHUXI", "SHUXI" ]

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MF", ".", "setAlignment", "(", "8", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "MCContext", "&", "Context", "=", "getObjFileLowering", "(", ")", ".", "getContext", "(", ")", ";", "MCSectionELF", "*", "ConfigSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.config\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ConfigSection", ")", ";", "const", "AMDGPUSubtarget", "&", "STM", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "SIProgramInfo", "KernelInfo", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "if", "(", "!", "STM", ".", "isAmdHsaOS", "(", ")", ")", "{", "getSIProgramInfo", "(", "KernelInfo", ",", "MF", ")", ";", "EmitProgramInfoSI", "(", "MF", ",", "KernelInfo", ")", ";", "}", "AMDGPUTargetStreamer", "*", "TS", "=", "static_cast", "<", "AMDGPUTargetStreamer", "*", ">", "(", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "TS", "->", "EmitDirectiveHSACodeObjectVersion", "(", "1", ",", "0", ")", ";", "AMDGPU", "::", "IsaVersion", "ISA", "=", "STM", ".", "getIsaVersion", "(", ")", ";", "TS", "->", "EmitDirectiveHSACodeObjectISA", "(", "ISA", ".", "Major", ",", "ISA", ".", "Minor", ",", "ISA", ".", "Stepping", ",", "\"AMD\"", ",", "\"AMDGPU\"", ")", ";", "}", "else", "{", "EmitProgramInfoR600", "(", "MF", ")", ";", "}", "DisasmLines", ".", "clear", "(", ")", ";", "HexLines", ".", "clear", "(", ")", ";", "DisasmLineMaxLen", "=", "0", ";", "EmitFunctionBody", "(", ")", ";", "if", "(", "isVerbose", "(", ")", ")", "{", "MCSectionELF", "*", "CommentSection", "=", "Context", ".", "getELFSection", "(", "\".AMDGPU.csdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "0", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "CommentSection", ")", ";", "if", "(", "STM", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", "{", "OutStreamer", "->", "emitRawComment", "(", "\" Kernel info:\"", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" codeLenInByte = \"", "+", "Twine", "(", "KernelInfo", ".", "CodeLen", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" NumSgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumSGPR", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" NumVgprs: \"", "+", "Twine", "(", "KernelInfo", ".", "NumVGPR", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" FloatMode: \"", "+", "Twine", "(", "KernelInfo", ".", "FloatMode", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" IeeeMode: \"", "+", "Twine", "(", "KernelInfo", ".", "IEEEMode", ")", ",", "false", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "\" ScratchSize: \"", "+", "Twine", "(", "KernelInfo", ".", "ScratchSize", ")", ",", "false", ")", ";", "}", "else", "{", "R600MachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "R600MachineFunctionInfo", ">", "(", ")", ";", "OutStreamer", "->", "emitRawComment", "(", "Twine", "(", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "+", "Twine", "(", "MFI", "->", "StackSize", ")", ")", ")", ";", "}", "}", "if", "(", "STM", ".", "dumpCode", "(", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "Context", ".", "getELFSection", "(", "\".AMDGPU.disasm\"", ",", "ELF", "::", "SHT_NOTE", ",", "0", ")", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "DisasmLines", ".", "size", "(", ")", ";", "++", "i", ")", "{", "std", "::", "string", "Comment", "(", "DisasmLineMaxLen", "-", "DisasmLines", "[", "i", "]", ".", "size", "(", ")", ",", "' '", ")", ";", "Comment", "+=", "\" ; \"", "+", "HexLines", "[", "i", "]", "+", "\"\\n\"", ";", "OutStreamer", "->", "EmitBytes", "(", "StringRef", "(", "DisasmLines", "[", "i", "]", ")", ")", ";", "OutStreamer", "->", "EmitBytes", "(", "StringRef", "(", "Comment", ")", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "8", "\".AMDGPU.config\"", "0", "AMDGPU", "AMDGPU", "SI", "AMDGPU", "SI", "SI", "AMDGPU", "AMDGPU", "1", "0", "AMDGPU::IsaVersion", "\"AMD\"", "\"AMDGPU\"", "R600", "0", "\".AMDGPU.csdata\"", "0", "AMDGPU", "\" Kernel info:\"", "\" codeLenInByte = \"", "\" NumSgprs: \"", "\" NumVgprs: \"", "\" FloatMode: \"", "\" IeeeMode: \"", "\" ScratchSize: \"", "R600", "R600", "\"SQ_PGM_RESOURCES:STACK_SIZE = \"", "\".AMDGPU.disasm\"", "0", "0", "\" ; \"", "\"\\n\"" ]

[]

[ "<s>", "void", "buildLoad", "(", "unsigned", "Val", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "unsigned", "Alignment", ",", "MachinePointerInfo", "&", "MPO", ")", "{", "auto", "MMO", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Alignment", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "Val", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "Build", "and", "insert", "a", "G_LOAD", "instruction", ",", "while", "constructing", "the", "MachineMemOperand", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "bool", "isAligned", "=", "(", "RI", ".", "getStackAlignment", "(", ")", ">=", "16", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "TM", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "notice_update_cc", "(", "rtx", "body", ",", "rtx", "insn", ")", "{", "switch", "(", "get_attr_cc", "(", "insn", ")", ")", "{", "case", "CC_NONE", ":", "break", ";", "case", "CC_NONE_0HIT", ":", "if", "(", "cc_status", ".", "value1", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "recog_data", ".", "operand", "[", "0", "]", ",", "cc_status", ".", "value1", ")", ")", "cc_status", ".", "value1", "=", "0", ";", "break", ";", "case", "CC_SET_ZN", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_OVERFLOW_UNUSABLE", "|", "CC_NO_CARRY", ";", "cc_status", ".", "value1", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "break", ";", "case", "CC_SET_ZNV", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "flags", "|=", "CC_NO_CARRY", ";", "cc_status", ".", "value1", "=", "recog_data", ".", "operand", "[", "0", "]", ";", "break", ";", "case", "CC_COMPARE", ":", "CC_STATUS_INIT", ";", "cc_status", ".", "value1", "=", "SET_SRC", "(", "body", ")", ";", "break", ";", "case", "CC_CLOBBER", ":", "CC_STATUS_INIT", ";", "break", ";", "}", "}", "</s>" ]

[ "On", "the", "68000", ",", "all", "the", "insns", "to", "store", "in", "an", "address", "register", "fail", "to", "set", "the", "cc", "'s", ".", "However", ",", "in", "some", "cases", "these", "instructions", "can", "make", "it", "possibly", "invalid", "to", "use", "the", "saved", "cc", "'s", ".", "In", "those", "cases", "we", "clear", "out", "some", "or", "all", "of", "the", "saved", "cc", "'s", "so", "they", "wo", "n't", "be", "used", "." ]

[ "v850", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "ok_for_simple_move_strict_operands", "(", "rtx", "*", "operands", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "visium_flags_exposed", "&&", "gpc_reg_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", "&&", "(", "gpc_reg_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", "||", "(", "mode", "==", "QImode", "&&", "operands", "[", "1", "]", "==", "const0_rtx", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "operands", "are", "valid", "for", "a", "simple", "move", "strict", "insn", "." ]

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

[]

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

[ "Return", "true", "if", "a", "select", "of", "constants", "(", "select", "Cond", ",", "C1", ",", "C2", ")", "should", "be", "transformed", "into", "simple", "math", "ops", "with", "the", "condition", "value", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "mips_set_frame_expr", "(", "rtx", "frame_pattern", ")", "{", "rtx_insn", "*", "insn", ";", "insn", "=", "get_last_insn", "(", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_FRAME_RELATED_EXPR", ",", "frame_pattern", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Make", "the", "last", "instruction", "frame", "related", "and", "note", "that", "it", "performs", "the", "operation", "described", "by", "FRAME_PATTERN", "." ]

[ "mips", "1" ]

[]

[ "<s>", "SDValue", "MCS51TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom lower this!\"", ")", ";", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "ROTL", ":", "case", "ISD", "::", "ROTR", ":", "return", "LowerShifts", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerDivRem", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "\"Don't know how to custom lower this!\"", "ISD::SHL", "ISD::SRA", "ISD::SRL", "ISD::ROTL", "ISD::ROTR", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::BR_CC", "ISD::SELECT_CC", "ISD::SETCC", "ISD::VASTART", "ISD::SDIVREM", "ISD::UDIVREM" ]

[]

[ "<s>", "void", "AArch64TargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64ISD", "::", "CSEL", ":", "{", "KnownBits", "Known2", ";", "Known", "=", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "0", ")", ",", "Depth", "+", "1", ")", ";", "Known2", "=", "DAG", ".", "computeKnownBits", "(", "Op", "->", "getOperand", "(", "1", ")", ",", "Depth", "+", "1", ")", ";", "Known", "=", "KnownBits", "::", "commonBits", "(", "Known", ",", "Known2", ")", ";", "break", ";", "}", "case", "AArch64ISD", "::", "LOADgot", ":", "case", "AArch64ISD", "::", "ADDlow", ":", "{", "if", "(", "!", "Subtarget", "->", "isTargetILP32", "(", ")", ")", "break", ";", "Known", ".", "Zero", "=", "APInt", "::", "getHighBitsSet", "(", "64", ",", "32", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "aarch64_ldaxr", ":", "case", "Intrinsic", "::", "aarch64_ldxr", ":", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "Known", ".", "Zero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "0", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "default", ":", "break", ";", "case", "Intrinsic", "::", "aarch64_neon_umaxv", ":", "case", "Intrinsic", "::", "aarch64_neon_uminv", ":", "{", "MVT", "VT", "=", "Op", ".", "getOperand", "(", "1", ")", ".", "getValueType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "v8i8", "||", "VT", "==", "MVT", "::", "v16i8", ")", "{", "assert", "(", "BitWidth", ">=", "8", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "8", ")", ";", "Known", ".", "Zero", "|=", "Mask", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "v4i16", "||", "VT", "==", "MVT", "::", "v8i16", ")", "{", "assert", "(", "BitWidth", ">=", "16", "&&", "\"Unexpected width!\"", ")", ";", "APInt", "Mask", "=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "16", ")", ";", "Known", ".", "Zero", "|=", "Mask", ";", "}", "break", ";", "}", "break", ";", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "AArch64", "AArch64", "AArch64ISD::CSEL", "0", "1", "1", "1", "AArch64ISD::LOADgot", "AArch64ISD::ADDlow", "64", "32", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::aarch64_ldaxr", "Intrinsic::aarch64_ldxr", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "0", "Intrinsic::aarch64_neon_umaxv", "Intrinsic::aarch64_neon_uminv", "1", "MVT::v8i8", "MVT::v16i8", "8", "\"Unexpected width!\"", "8", "MVT::v4i16", "MVT::v8i16", "16", "\"Unexpected width!\"", "16" ]

[]

[ "<s>", "void", "MipsInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "DebugLoc", "DL", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "RISCV", "::", "SB", ":", "case", "RISCV", "::", "SH", ":", "case", "RISCV", "::", "SW", ":", "case", "RISCV", "::", "FSH", ":", "case", "RISCV", "::", "FSW", ":", "case", "RISCV", "::", "SD", ":", "case", "RISCV", "::", "FSD", ":", "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>" ]

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

[ "RI5CY", "RISCV", "0", "RISCV::SB", "RISCV::SH", "RISCV::SW", "RISCV::FSH", "RISCV::FSW", "RISCV::SD", "RISCV::FSD", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "BitVector", "AGCRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "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", "." ]

[ "AGC", "AGC" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "hasPairedLoad", "(", "EVT", "LoadedType", ",", "Align", "&", "RequiredAligment", ")", "const", "{", "if", "(", "!", "LoadedType", ".", "isSimple", "(", ")", "||", "(", "!", "LoadedType", ".", "isInteger", "(", ")", "&&", "!", "LoadedType", ".", "isFloatingPoint", "(", ")", ")", ")", "return", "false", ";", "RequiredAligment", "=", "Align", "(", "1", ")", ";", "unsigned", "NumBits", "=", "LoadedType", ".", "getSizeInBits", "(", ")", ";", "return", "NumBits", "==", "32", "||", "NumBits", "==", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supplies", "and", "combines", "to", "a", "paired", "load", "two", "loaded", "values", "of", "type", "LoadedType", "next", "to", "each", "other", "in", "memory", "." ]

[ "AArch64", "AArch64", "1", "32", "64" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "else", "return", "true", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"" ]

[]

[ "<s>", "unsigned", "DCPU16InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "DCPU16", "::", "MOV16rm", ")", "{", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "{", "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", "." ]

[ "Dcpu16", "DCPU16", "DCPU16::MOV16rm", "1", "1", "0", "0" ]

[]

[ "<s>", "uint64_t", "R600MCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixup", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "HAS_NATIVE_OPERANDS", "(", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ")", ")", "{", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "else", "{", "return", "getHWReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "MO", ".", "getImm", "(", ")", ";", "}", "else", "{", "assert", "(", "0", ")", ";", "return", "0", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_register_pragmas", "(", "void", ")", "{", "targetm", ".", "target_option", ".", "pragma_parse", "=", "ix86_pragma_target_parse", ";", "c_register_addr_space", "(", "\"__seg_fs\"", ",", "ADDR_SPACE_SEG_FS", ")", ";", "c_register_addr_space", "(", "\"__seg_gs\"", ",", "ADDR_SPACE_SEG_GS", ")", ";", "REGISTER_SUBTARGET_PRAGMAS", "(", ")", ";", "}", "</s>" ]

[ "Register", "target", "pragmas", ".", "We", "need", "to", "add", "the", "hook", "for", "parsing", "#", "pragma", "GCC", "option", "here", "rather", "than", "in", "i386.cc", "since", "it", "will", "pull", "in", "various", "preprocessor", "functions", ",", "and", "those", "are", "not", "present", "in", "languages", "like", "fortran", "without", "a", "preprocessor", "." ]

[ "i386", "\"__seg_fs\"", "\"__seg_gs\"" ]

[]

[ "<s>", "static", "int", "gen_v9_scc", "(", "rtx", "dest", ",", "enum", "rtx_code", "compare_code", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "if", "(", "!", "TARGET_ARCH64", "&&", "(", "GET_MODE", "(", "x", ")", "==", "DImode", "||", "GET_MODE", "(", "dest", ")", "==", "DImode", ")", ")", "return", "0", ";", "if", "(", "TARGET_ARCH64", "&&", "GET_MODE_CLASS", "(", "GET_MODE", "(", "x", ")", ")", "==", "MODE_INT", "&&", "y", "==", "const0_rtx", "&&", "v9_regcmp_p", "(", "compare_code", ")", ")", "{", "rtx", "op0", "=", "x", ";", "rtx", "temp", ";", "if", "(", "compare_code", "==", "NE", "&&", "GET_MODE", "(", "dest", ")", "==", "DImode", "&&", "rtx_equal_p", "(", "op0", ",", "dest", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "DImode", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "DImode", ",", "op0", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "dest", ")", ")", ")", ";", "return", "1", ";", "}", "if", "(", "reg_overlap_mentioned_p", "(", "dest", ",", "op0", ")", ")", "{", "op0", "=", "gen_reg_rtx", "(", "GET_MODE", "(", "x", ")", ")", ";", "emit_move_insn", "(", "op0", ",", "x", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "const0_rtx", ")", ")", ";", "if", "(", "GET_MODE", "(", "op0", ")", "!=", "DImode", ")", "{", "temp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "temp", ",", "op0", ",", "0", ")", ";", "}", "else", "temp", "=", "op0", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "DImode", ",", "temp", ",", "const0_rtx", ")", ",", "const1_rtx", ",", "dest", ")", ")", ")", ";", "return", "1", ";", "}", "else", "{", "x", "=", "gen_compare_reg_1", "(", "compare_code", ",", "x", ",", "y", ")", ";", "y", "=", "const0_rtx", ";", "gcc_assert", "(", "GET_MODE", "(", "x", ")", "!=", "CC_NOOVmode", "&&", "GET_MODE", "(", "x", ")", "!=", "CCX_NOOVmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "const0_rtx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "gen_rtx_IF_THEN_ELSE", "(", "GET_MODE", "(", "dest", ")", ",", "gen_rtx_fmt_ee", "(", "compare_code", ",", "GET_MODE", "(", "x", ")", ",", "x", ",", "y", ")", ",", "const1_rtx", ",", "dest", ")", ")", ")", ";", "return", "1", ";", "}", "}", "</s>" ]

[ "This", "function", "is", "used", "for", "v9", "only", ".", "CODE", "is", "the", "code", "for", "an", "Scc", "'s", "comparison", ".", "OPERANDS", "[", "0", "]", "is", "the", "target", "of", "the", "Scc", "insn", ".", "OPERANDS", "[", "1", "]", "is", "the", "value", "we", "compare", "against", "const0_rtx", "(", "which", "has", "n't", "been", "generated", "yet", ")", ".", "This", "function", "is", "needed", "to", "turn", "(", "set", "(", "reg", ":", "SI", "110", ")", "(", "gt", "(", "reg", ":", "CCX", "100", "%", "icc", ")", "(", "const_int", "0", ")", ")", ")", "into", "(", "set", "(", "reg", ":", "SI", "110", ")", "(", "gt", ":", "DI", "(", "reg", ":", "CCX", "100", "%", "icc", ")", "(", "const_int", "0", ")", ")", ")", "IE", ":", "The", "instruction", "recognizer", "needs", "to", "see", "the", "mode", "of", "the", "comparison", "to", "find", "the", "right", "instruction", ".", "We", "could", "use", "``", "gt", ":", "DI", "''", "right", "in", "the", "define_expand", ",", "but", "leaving", "it", "out", "allows", "us", "to", "handle", "DI", ",", "SI", ",", "etc", ".", "We", "refer", "to", "the", "global", "sparc", "compare", "operands", "sparc_compare_op0", "and", "sparc_compare_op1", "." ]

[ "sparc", "0", "1", "0", "1", "1" ]

[]

[ "<s>", "bool", "ARM64AsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "if", "(", "(", "Count", "&", "3", ")", "!=", "0", ")", "{", "for", "(", "uint64_t", "i", "=", "0", ",", "e", "=", "(", "Count", "&", "3", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OW", "->", "Write8", "(", "0", ")", ";", "}", "Count", "/=", "4", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "!=", "Count", ";", "++", "i", ")", "OW", "->", "Write32", "(", "0xd503201f", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "3", "0", "0", "3", "0", "4", "0", "0xd503201f" ]

[]

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

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

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

[]

[ "<s>", "static", "enum", "arm_pcs", "arm_get_pcs_model", "(", "const_tree", "type", ",", "const_tree", "decl", "ATTRIBUTE_UNUSED", ")", "{", "bool", "user_convention", "=", "false", ";", "enum", "arm_pcs", "user_pcs", "=", "arm_pcs_default", ";", "tree", "attr", ";", "gcc_assert", "(", "type", ")", ";", "attr", "=", "lookup_attribute", "(", "\"pcs\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "if", "(", "attr", ")", "{", "user_pcs", "=", "arm_pcs_from_attribute", "(", "TREE_VALUE", "(", "attr", ")", ")", ";", "user_convention", "=", "true", ";", "}", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "bool", "base_rules", "=", "stdarg_p", "(", "type", ")", ";", "if", "(", "user_convention", ")", "{", "if", "(", "user_pcs", ">", "ARM_PCS_AAPCS_LOCAL", ")", "sorry", "(", "\"non-AAPCS derived PCS variant\"", ")", ";", "else", "if", "(", "base_rules", "&&", "user_pcs", "!=", "ARM_PCS_AAPCS", ")", "error", "(", "\"variadic functions must use the base AAPCS variant\"", ")", ";", "}", "if", "(", "base_rules", ")", "return", "ARM_PCS_AAPCS", ";", "else", "if", "(", "user_convention", ")", "return", "user_pcs", ";", "else", "if", "(", "decl", "&&", "flag_unit_at_a_time", ")", "{", "cgraph_node", "*", "local_info_node", "=", "cgraph_node", "::", "local_info_node", "(", "CONST_CAST_TREE", "(", "decl", ")", ")", ";", "if", "(", "local_info_node", "&&", "local_info_node", "->", "local", ")", "return", "ARM_PCS_AAPCS_LOCAL", ";", "}", "}", "else", "if", "(", "user_convention", "&&", "user_pcs", "!=", "arm_pcs_default", ")", "sorry", "(", "\"PCS variant\"", ")", ";", "return", "arm_pcs_default", ";", "}", "</s>" ]

[ "Get", "the", "PCS", "variant", "to", "use", "for", "this", "call", ".", "TYPE", "is", "the", "function", "'s", "type", "specification", ",", "DECL", "is", "the", "specific", "declartion", ".", "DECL", "may", "be", "null", "if", "the", "call", "could", "be", "indirect", "or", "if", "this", "is", "a", "library", "call", "." ]

[ "arm", "\"pcs\"", "\"non-AAPCS derived PCS variant\"", "\"variadic functions must use the base AAPCS variant\"", "\"PCS variant\"" ]

[]

[ "<s>", "void", "HexagonMCELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "MCB", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", ")", "{", "assert", "(", "MCB", ".", "getOpcode", "(", ")", "==", "Hexagon", "::", "BUNDLE", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<=", "HEXAGON_PACKET_SIZE", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", ">", "0", ")", ";", "for", "(", "auto", "const", "&", "I", ":", "HexagonMCInstrInfo", "::", "bundleInstructions", "(", "MCB", ")", ")", "{", "MCInst", "*", "MCI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "I", ".", "getInst", "(", ")", ")", ";", "EmitSymbol", "(", "*", "MCI", ")", ";", "}", "MCObjectStreamer", "::", "EmitInstruction", "(", "MCB", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::BUNDLE", "Hexagon", "Hexagon", "0", "Hexagon" ]

[]

[ "<s>", "void", "function_builder", "::", "allocate_argument_types", "(", "const", "function_instance", "&", "instance", ",", "vec", "<", "tree", ">", "&", "argument_types", ")", "const", "{", "for", "(", "unsigned", "int", "i", "=", "0", ";", "instance", ".", "op_info", "->", "args", "[", "i", "]", ".", "base_type", "!=", "NUM_BASE_TYPES", ";", "++", "i", ")", "argument_types", ".", "quick_push", "(", "instance", ".", "op_info", "->", "args", "[", "i", "]", ".", "get_tree_type", "(", "instance", ".", "type", ".", "index", ")", ")", ";", "}", "</s>" ]

[ "Allocate", "arguments", "of", "the", "function", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "const", "auto", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "Opcode", "==", "AMDGPU", "::", "S_SETPC_B64_return", ")", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "else", "if", "(", "Opcode", "==", "AMDGPU", "::", "SI_CALL", ")", "{", "OutMI", ".", "setOpcode", "(", "TII", "->", "pseudoToMCOpcode", "(", "AMDGPU", "::", "S_SWAPPC_B64", ")", ")", ";", "MCOperand", "Dest", ",", "Src", ";", "lowerOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ",", "Dest", ")", ";", "lowerOperand", "(", "MI", "->", "getOperand", "(", "1", ")", ",", "Src", ")", ";", "OutMI", ".", "addOperand", "(", "Dest", ")", ";", "OutMI", ".", "addOperand", "(", "Src", ")", ";", "return", ";", "}", "else", "if", "(", "Opcode", "==", "AMDGPU", "::", "SI_TCRETURN", ")", "{", "Opcode", "=", "AMDGPU", "::", "S_SETPC_B64", ";", "}", "int", "MCOpcode", "=", "TII", "->", "pseudoToMCOpcode", "(", "Opcode", ")", ";", "if", "(", "MCOpcode", "==", "-", "1", ")", "{", "LLVMContext", "&", "C", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", ")", ".", "getContext", "(", ")", ";", "C", ".", "emitError", "(", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"", "+", "Twine", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ";", "}", "OutMI", ".", "setOpcode", "(", "MCOpcode", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "lowerOperand", "(", "MO", ",", "MCOp", ")", ";", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "AMDGPU", "AMDGPU", "SI", "AMDGPU::S_SETPC_B64_return", "AMDGPU::S_SETPC_B64", "AMDGPU::SI_CALL", "AMDGPU::S_SWAPPC_B64", "0", "1", "AMDGPU::SI_TCRETURN", "AMDGPU::S_SETPC_B64", "1", "\"AMDGPUMCInstLower::lower - Pseudo instruction doesn't have \"", "\"a target-specific version: \"" ]

[]

[ "<s>", "void", "HexagonDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "SelectionDAG", "&", "DAG", "=", "*", "CurDAG", ";", "std", "::", "vector", "<", "SDNode", "*", ">", "Nodes", ";", "for", "(", "SDNode", "&", "Node", ":", "DAG", ".", "allnodes", "(", ")", ")", "Nodes", ".", "push_back", "(", "&", "Node", ")", ";", "for", "(", "auto", "I", ":", "Nodes", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "OR", ")", "continue", ";", "auto", "IsZero", "=", "[", "]", "(", "const", "SDValue", "&", "V", ")", "->", "bool", "{", "if", "(", "ConstantSDNode", "*", "SC", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "V", ".", "getNode", "(", ")", ")", ")", "return", "SC", "->", "isNullValue", "(", ")", ";", "return", "false", ";", "}", ";", "auto", "IsSelect0", "=", "[", "IsZero", "]", "(", "const", "SDValue", "&", "Op", ")", "->", "bool", "{", "if", "(", "Op", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SELECT", ")", "return", "false", ";", "return", "IsZero", "(", "Op", ".", "getOperand", "(", "1", ")", ")", "||", "IsZero", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "}", ";", "SDValue", "N0", "=", "I", "->", "getOperand", "(", "0", ")", ",", "N1", "=", "I", "->", "getOperand", "(", "1", ")", ";", "EVT", "VT", "=", "I", "->", "getValueType", "(", "0", ")", ";", "bool", "SelN0", "=", "IsSelect0", "(", "N0", ")", ";", "SDValue", "SOp", "=", "SelN0", "?", "N0", ":", "N1", ";", "SDValue", "VOp", "=", "SelN0", "?", "N1", ":", "N0", ";", "if", "(", "SOp", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "&&", "SOp", ".", "getNode", "(", ")", "->", "hasOneUse", "(", ")", ")", "{", "SDValue", "SC", "=", "SOp", ".", "getOperand", "(", "0", ")", ";", "SDValue", "SX", "=", "SOp", ".", "getOperand", "(", "1", ")", ";", "SDValue", "SY", "=", "SOp", ".", "getOperand", "(", "2", ")", ";", "SDLoc", "DLS", "=", "SOp", ";", "if", "(", "IsZero", "(", "SY", ")", ")", "{", "SDValue", "NewOr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DLS", ",", "VT", ",", "SX", ",", "VOp", ")", ";", "SDValue", "NewSel", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "DLS", ",", "VT", ",", "SC", ",", "NewOr", ",", "VOp", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "I", ",", "NewSel", ".", "getNode", "(", ")", ")", ";", "}", "else", "if", "(", "IsZero", "(", "SX", ")", ")", "{", "SDValue", "NewOr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "OR", ",", "DLS", ",", "VT", ",", "SY", ",", "VOp", ")", ";", "SDValue", "NewSel", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SELECT", ",", "DLS", ",", "VT", ",", "SC", ",", "VOp", ",", "NewOr", ")", ";", "DAG", ".", "ReplaceAllUsesWith", "(", "I", ",", "NewSel", ".", "getNode", "(", ")", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "Hexagon", "Hexagon", "ISD::OR", "ISD::SELECT", "1", "2", "0", "1", "0", "ISD::SELECT", "0", "1", "2", "ISD::OR", "ISD::SELECT", "ISD::OR", "ISD::SELECT" ]

[]

[ "<s>", "bool", "NyuziTTIImpl", "::", "hasBranchDivergence", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "Nyuzi", "Nyuzi" ]

[]

[ "<s>", "static", "int", "fp_regs_to_save", "(", "void", ")", "{", "int", "i", ",", "n", "=", "0", ";", "if", "(", "!", "TARGET_AM33_2", ")", "return", "0", ";", "for", "(", "i", "=", "FIRST_FP_REGNUM", ";", "i", "<=", "LAST_FP_REGNUM", ";", "++", "i", ")", "if", "(", "df_regs_ever_live_p", "(", "i", ")", "&&", "!", "call_really_used_regs", "[", "i", "]", ")", "++", "n", ";", "return", "n", ";", "}", "</s>" ]

[ "Count", "the", "number", "of", "FP", "registers", "that", "have", "to", "be", "saved", "." ]

[ "mn10300", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUFixFunctionBitcastsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", ")", "addPass", "(", "createR600OpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "if", "(", "EnableScalarIRPasses", ")", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableScalarIRPasses", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "R600", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "AMDGPUInstrInfo", "::", "unfoldMemoryOperand", "(", "SelectionDAG", "&", "DAG", ",", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "NewNodes", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "unfoldMemoryOperand", "-", "Separate", "a", "single", "instruction", "which", "folded", "a", "load", "or", "a", "store", "or", "a", "load", "and", "a", "store", "into", "two", "or", "more", "instruction", "." ]

[ "R600" ]

[]

[ "<s>", "void", "ARCompactInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "ARC", "::", "LDrli", ")", ")", ".", "addReg", "(", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "ARCompact", "ARC", "ARC::LDrli", "0" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "{", "if", "(", "processInstruction", "(", "Inst", ",", "IDLoc", ",", "Instructions", ")", ")", "return", "true", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Instructions", ".", "size", "(", ")", ";", "i", "++", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "return", "false", ";", "}", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "return", "false", ";", "}", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ";", "++", "I", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "RISCVOperand", "&", ")", "*", "Operands", "[", "ErrorInfo", "]", ")", ".", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "RISCV", "\"invalid operand for instruction\"", "\"invalid instruction\"" ]

[]

[ "<s>", "bool", "csky_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_TLS", ")", "return", "false", ";", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "x", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS", ")", "iter", ".", "skip_subrtxes", "(", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "contains", "any", "references", "to", "TLS", "symbols", "." ]

[ "csky", "0", "1" ]

[]

[ "<s>", "static", "bool", "ia64_legitimate_address_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "ia64_legitimate_address_reg", "(", "x", ",", "strict", ")", ")", "return", "true", ";", "else", "if", "(", "(", "GET_CODE", "(", "x", ")", "==", "POST_INC", "||", "GET_CODE", "(", "x", ")", "==", "POST_DEC", ")", "&&", "ia64_legitimate_address_reg", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", "&&", "XEXP", "(", "x", ",", "0", ")", "!=", "arg_pointer_rtx", ")", "return", "true", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "POST_MODIFY", "&&", "ia64_legitimate_address_reg", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", "&&", "XEXP", "(", "x", ",", "0", ")", "!=", "arg_pointer_rtx", "&&", "ia64_legitimate_address_disp", "(", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "1", ")", ",", "strict", ")", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

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

[]

[ "<s>", "void", "XCoreFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "if", "(", "FP", ")", "{", "unsigned", "FramePtr", "=", "XCore", "::", "R10", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "XCore", "::", "SETSP_1r", ")", ")", ".", "addReg", "(", "FramePtr", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "4", "==", "0", "&&", "\"Misaligned frame size\"", ")", ";", "FrameSize", "/=", "4", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "report_fatal_error", "(", "\"emitEpilogue Frame size too big: \"", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "FPSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "R10", ",", "FPSpillOffset", ",", "dl", ",", "TII", ")", ";", "}", "bool", "restoreLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "if", "(", "restoreLR", "&&", "(", "FrameSize", "==", "0", "||", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "!=", "0", ")", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "LRSpillOffset", "+=", "FrameSize", "*", "4", ";", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "XCore", "::", "LR", ",", "LRSpillOffset", ",", "dl", ",", "TII", ")", ";", "restoreLR", "=", "false", ";", "}", "if", "(", "FrameSize", ")", "{", "if", "(", "restoreLR", ")", "{", "assert", "(", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "==", "0", ")", ";", "assert", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_u6", "||", "MBBI", "->", "getOpcode", "(", ")", "==", "XCore", "::", "RETSP_lu6", ")", ";", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "RETSP_u6", ":", "XCore", "::", "RETSP_lu6", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "3", ",", "e", "=", "MBBI", "->", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "MIB", "->", "addOperand", "(", "MBBI", "->", "getOperand", "(", "i", ")", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "int", "Opcode", "=", "(", "isU6", ")", "?", "XCore", "::", "LDAWSP_ru6", ":", "XCore", "::", "LDAWSP_lru6", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "XCore", "::", "SP", ")", ".", "addImm", "(", "FrameSize", ")", ";", "}", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore", "XCore", "XCore", "XCore::R10", "XCore::SETSP_1r", "4", "0", "\"Misaligned frame size\"", "4", "\"emitEpilogue Frame size too big: \"", "4", "XCore::R10", "0", "0", "4", "XCore::LR", "0", "XCore::RETSP_u6", "XCore::RETSP_lu6", "XCore::RETSP_u6", "XCore::RETSP_lu6", "3", "XCore::LDAWSP_ru6", "XCore::LDAWSP_lru6", "XCore::SP" ]

[]

[ "<s>", "void", "CSKYRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected non-zero SPAdj value\"", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "0", "\"Unexpected non-zero SPAdj value\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "HexagonHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "!", "MI", "||", "TII", "->", "isZeroCost", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "return", "NoHazard", ";", "if", "(", "!", "Resources", "->", "canReserveResources", "(", "*", "MI", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** Hazard in cycle \"", "<<", "PacketNum", "<<", "\", \"", "<<", "*", "MI", ")", ";", "HazardType", "RetVal", "=", "Hazard", ";", "if", "(", "TII", "->", "mayBeNewStore", "(", "*", "MI", ")", ")", "{", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "MI", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "RegDefs", ".", "count", "(", "MO", ".", "getReg", "(", ")", ")", "==", "0", ")", "return", "Hazard", ";", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "MF", "->", "CreateMachineInstr", "(", "TII", "->", "get", "(", "TII", "->", "getDotNewOp", "(", "*", "MI", ")", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ")", ";", "if", "(", "Resources", "->", "canReserveResources", "(", "*", "NewMI", ")", ")", "RetVal", "=", "NoHazard", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** Try .new version? \"", "<<", "(", "RetVal", "==", "NoHazard", ")", "<<", "\"\\n\"", ")", ";", "MF", "->", "DeleteMachineInstr", "(", "NewMI", ")", ";", "}", "return", "RetVal", ";", "}", "if", "(", "SU", "==", "UsesDotCur", "&&", "DotCurPNum", "!=", "(", "int", ")", "PacketNum", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** .cur Hazard in cycle \"", "<<", "PacketNum", "<<", "\", \"", "<<", "*", "MI", ")", ";", "return", "Hazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"*** Hazard in cycle \"", "\", \"", "1", "0", "\"*** Try .new version? \"", "\"\\n\"", "\"*** .cur Hazard in cycle \"", "\", \"" ]

[]

[ "<s>", "static", "unsigned", "char", "ix86_class_max_nregs", "(", "reg_class_t", "rclass", ",", "machine_mode", "mode", ")", "{", "if", "(", "MAYBE_INTEGER_CLASS_P", "(", "rclass", ")", ")", "{", "if", "(", "mode", "==", "XFmode", ")", "return", "(", "TARGET_64BIT", "?", "2", ":", "3", ")", ";", "else", "if", "(", "mode", "==", "XCmode", ")", "return", "(", "TARGET_64BIT", "?", "4", ":", "6", ")", ";", "else", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "else", "{", "if", "(", "COMPLEX_MODE_P", "(", "mode", ")", ")", "return", "2", ";", "else", "return", "1", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_CLASS_MAX_NREGS", "hook", ".", "On", "the", "80386", ",", "this", "is", "the", "size", "of", "MODE", "in", "words", ",", "except", "in", "the", "FP", "regs", ",", "where", "a", "single", "reg", "is", "always", "enough", "." ]

[ "i386", "2", "3", "4", "6", "2", "1" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "insertIndirectBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "&", "DestBB", ",", "const", "DebugLoc", "&", "DL", ",", "int64_t", "BrOffset", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "RS", "&&", "\"RegScavenger required for long branching\"", ")", ";", "assert", "(", "MBB", ".", "empty", "(", ")", "&&", "\"new block should be inserted for expanding unconditional branch\"", ")", ";", "assert", "(", "MBB", ".", "pred_size", "(", ")", "==", "1", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "if", "(", "!", "isInt", "<", "32", ">", "(", "BrOffset", ")", ")", "report_fatal_error", "(", "\"Branch offsets outside of the signed 32-bit range not supported\"", ")", ";", "Register", "ScratchReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "RISCV", "::", "GPRRegClass", ")", ";", "auto", "II", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "&", "MI", "=", "*", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "get", "(", "RISCV", "::", "PseudoJump", ")", ")", ".", "addReg", "(", "ScratchReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Dead", ")", ".", "addMBB", "(", "&", "DestBB", ",", "RISCVII", "::", "MO_CALL", ")", ";", "RS", "->", "enterBasicBlockEnd", "(", "MBB", ")", ";", "unsigned", "Scav", "=", "RS", "->", "scavengeRegisterBackwards", "(", "RISCV", "::", "GPRRegClass", ",", "MI", ".", "getIterator", "(", ")", ",", "false", ",", "0", ")", ";", "MRI", ".", "replaceRegWith", "(", "ScratchReg", ",", "Scav", ")", ";", "MRI", ".", "clearVirtRegs", "(", ")", ";", "RS", "->", "setRegUsed", "(", "Scav", ")", ";", "return", "8", ";", "}", "</s>" ]

[ "Insert", "an", "unconditional", "indirect", "branch", "at", "the", "end", "of", "MBB", "to", "NewDestBB", "." ]

[ "RISCV", "RISCV", "\"RegScavenger required for long branching\"", "\"new block should be inserted for expanding unconditional branch\"", "1", "32", "\"Branch offsets outside of the signed 32-bit range not supported\"", "RISCV::GPRRegClass", "RISCV::PseudoJump", "RISCVII::MO_CALL", "RISCV::GPRRegClass", "0", "8" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameLoadOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isLoadFromStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "const", "MachineMemOperand", "*", "Dummy", ";", "return", "hasLoadFromStackSlot", "(", "MI", ",", "Dummy", ",", "FrameIndex", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "void", "mips_final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", ",", "int", "noperands", ")", "{", "if", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "UNSPEC_VOLATILE", "&&", "XINT", "(", "PATTERN", "(", "insn", ")", ",", "1", ")", "==", "UNSPEC_CONSTTABLE", ")", "mips_set_text_contents_type", "(", "asm_out_file", ",", "\"__pool_\"", ",", "INTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "0", ",", "0", ")", ")", ",", "FALSE", ")", ";", "if", "(", "mips_need_noat_wrapper_p", "(", "insn", ",", "opvec", ",", "noperands", ")", ")", "mips_push_asm_switch", "(", "&", "mips_noat", ")", ";", "}", "</s>" ]

[ "Implement", "FINAL_PRESCAN_INSN", "." ]

[ "mips", "1", "\"__pool_\"", "0", "0" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "createSIInsertWaitsPass", "(", ")", ")", ";", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "createSIDebuggerInsertNopsPass", "(", ")", ")", ";", "addPass", "(", "&", "BranchRelaxationPassID", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "virtual", "const", "TargetRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "XNCM" ]

[]

[ "<s>", "bool", "MOSInstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "MachineIRBuilder", "Builder", "(", "MI", ")", ";", "bool", "Changed", "=", "true", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Changed", "=", "false", ";", "break", ";", "case", "MOS", "::", "INC", ":", "case", "MOS", "::", "DEC", ":", "expandIncDec", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "LDAbsIdx", ":", "expandLDIdx", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "LDImm1", ":", "expandLDImm1", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "LDImm16", ":", "expandLDImm16", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "LDImm16Remat", ":", "expandLDImm16Remat", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "LDZ", ":", "expandLDZ", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "CMPNZImm", ":", "case", "MOS", "::", "CMPNZImag8", ":", "case", "MOS", "::", "CMPNZAbs", ":", "case", "MOS", "::", "CMPNZAbsIdx", ":", "case", "MOS", "::", "CMPNZIndirIdx", ":", "case", "MOS", "::", "SBCNZImm", ":", "case", "MOS", "::", "SBCNZImag8", ":", "case", "MOS", "::", "SBCNZAbs", ":", "case", "MOS", "::", "SBCNZAbsIdx", ":", "case", "MOS", "::", "SBCNZIndirIdx", ":", "expandNZ", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "CMPTermImm", ":", "case", "MOS", "::", "CMPTermImag8", ":", "case", "MOS", "::", "CMPTermAbs", ":", "case", "MOS", "::", "CMPTermIndir", ":", "case", "MOS", "::", "CMPTermIdx", ":", "expandCMPTerm", "(", "Builder", ")", ";", "break", ";", "case", "MOS", "::", "GBR", ":", "expandGBR", "(", "Builder", ")", ";", "break", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "MOS", "MOS", "MOS::INC", "MOS::DEC", "MOS::LDAbsIdx", "MOS::LDImm1", "MOS::LDImm16", "MOS::LDImm16Remat", "MOS::LDZ", "MOS::CMPNZImm", "MOS::CMPNZImag8", "MOS::CMPNZAbs", "MOS::CMPNZAbsIdx", "MOS::CMPNZIndirIdx", "MOS::SBCNZImm", "MOS::SBCNZImag8", "MOS::SBCNZAbs", "MOS::SBCNZAbsIdx", "MOS::SBCNZIndirIdx", "MOS::CMPTermImm", "MOS::CMPTermImag8", "MOS::CMPTermAbs", "MOS::CMPTermIndir", "MOS::CMPTermIdx", "MOS::GBR" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "return", ";", "}", "if", "(", "TII", "->", "isMIMG", "(", "*", "MI", ")", ")", "{", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "DmaskIdx", "=", "MI", "->", "getNumOperands", "(", ")", "==", "12", "?", "3", ":", "4", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "DmaskIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "0", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'hasPostISelHook", "'", "flag", "." ]

[ "AMDGPU", "SI", "SI", "SI", "0", "12", "3", "4", "0", "0", "4", "1", "1", "0", "1", "AMDGPU::VGPR_32RegClass", "2", "AMDGPU::VReg_64RegClass", "3", "AMDGPU::VReg_96RegClass", "AMDGPU::getAtomicNoRetOp", "1", "0", "0" ]

[]

[ "<s>", "static", "rtx", "sparc_struct_value_rtx", "(", "tree", "fndecl", ",", "int", "incoming", ")", "{", "if", "(", "TARGET_ARCH64", ")", "return", "0", ";", "else", "{", "rtx", "mem", ";", "if", "(", "incoming", ")", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "STRUCT_VALUE_OFFSET", ")", ")", ";", "else", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "STRUCT_VALUE_OFFSET", ")", ")", ";", "if", "(", "incoming", "==", "2", "&&", "sparc_std_struct_return", "&&", "TYPE_SIZE_UNIT", "(", "TREE_TYPE", "(", "fndecl", ")", ")", "&&", "TREE_CODE", "(", "TYPE_SIZE_UNIT", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ")", "==", "INTEGER_CST", ")", "{", "rtx", "ret_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "scratch", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "endlab", "=", "gen_label_rtx", "(", ")", ";", "tree", "size", "=", "TYPE_SIZE_UNIT", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "rtx", "size_rtx", "=", "GEN_INT", "(", "TREE_INT_CST_LOW", "(", "size", ")", "&", "0xfff", ")", ";", "rtx", "temp_val", "=", "assign_stack_local", "(", "Pmode", ",", "TREE_INT_CST_LOW", "(", "size", ")", ",", "0", ")", ";", "emit_move_insn", "(", "scratch", ",", "gen_rtx_MEM", "(", "SImode", ",", "plus_constant", "(", "Pmode", ",", "ret_reg", ",", "8", ")", ")", ")", ";", "emit_insn", "(", "gen_add3_insn", "(", "ret_reg", ",", "ret_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "emit_cmp_and_jump_insns", "(", "scratch", ",", "size_rtx", ",", "EQ", ",", "const0_rtx", ",", "SImode", ",", "0", ",", "endlab", ")", ";", "emit_insn", "(", "gen_sub3_insn", "(", "ret_reg", ",", "ret_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "XEXP", "(", "temp_val", ",", "0", ")", ")", ";", "emit_label", "(", "endlab", ")", ";", "}", "return", "mem", ";", "}", "}", "</s>" ]

[ "Handle", "the", "TARGET_STRUCT_VALUE", "target", "hook", ".", "Return", "where", "to", "find", "the", "structure", "return", "value", "address", "." ]

[ "sparc", "0", "2", "0xfff", "0", "8", "4", "0", "4", "0" ]

[]

[ "<s>", "bool", "PPCSubtarget", "::", "useAA", "(", ")", "const", "{", "return", "needsAggressiveScheduling", "(", "DarwinDirective", ")", ";", "}", "</s>" ]

[ "Enable", "use", "of", "alias", "analysis", "during", "code", "generation", "(", "during", "MI", "scheduling", ",", "DAGCombine", ",", "etc", ".", ")", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "void", "PPCDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "SelectionDAG", "::", "allnodes_iterator", "Position", "(", "CurDAG", "->", "getRoot", "(", ")", ".", "getNode", "(", ")", ")", ";", "++", "Position", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "Position", "!=", "CurDAG", "->", "allnodes_begin", "(", ")", ")", "{", "SDNode", "*", "N", "=", "&", "*", "--", "Position", ";", "if", "(", "N", "->", "use_empty", "(", ")", ")", "continue", ";", "SDValue", "Res", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "OR", ":", "Res", "=", "combineToCMPB", "(", "N", ")", ";", "break", ";", "}", "if", "(", "!", "Res", ")", "foldBoolExts", "(", "Res", ",", "N", ")", ";", "if", "(", "Res", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"PPC DAG preprocessing replacing:\\nOld: \"", ")", ";", "LLVM_DEBUG", "(", "N", "->", "dump", "(", "CurDAG", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nNew: \"", ")", ";", "LLVM_DEBUG", "(", "Res", ".", "getNode", "(", ")", "->", "dump", "(", "CurDAG", ")", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Res", ")", ";", "MadeChange", "=", "true", ";", "}", "}", "if", "(", "MadeChange", ")", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "PowerPC", "PPC", "ISD::OR", "\"PPC DAG preprocessing replacing:\\nOld: \"", "\"\\nNew: \"", "\"\\n\"", "0" ]

[]

[ "<s>", "static", "char", "*", "to_host_file_spec", "(", "char", "*", "filespec", ")", "{", "strcpy", "(", "new_host_filespec", ",", "\"\"", ")", ";", "if", "(", "strchr", "(", "filespec", ",", "']'", ")", "||", "strchr", "(", "filespec", ",", "':'", ")", ")", "strcpy", "(", "new_host_filespec", ",", "filespec", ")", ";", "else", "{", "decc$to_vms", "(", "filespec", ",", "translate_unix", ",", "1", ",", "1", ")", ";", "strcpy", "(", "new_host_filespec", ",", "filename_buff", ")", ";", "}", "return", "new_host_filespec", ";", "}", "</s>" ]

[ "Translate", "a", "Unix", "syntax", "file", "specification", "FILESPEC", "into", "VMS", "syntax", ".", "If", "indicators", "of", "VMS", "syntax", "found", ",", "return", "input", "string", ".", "Return", "a", "pointer", "to", "a", "static", "buffer", "." ]

[ "alpha", "\"\"", "1", "1" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TBA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TMA", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP0_TTMP1", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP2_TTMP3", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP4_TTMP5", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP6_TTMP7", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP8_TTMP9", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "TTMP10_TTMP11", ")", ";", "unsigned", "MaxWorkGroupSGPRCount", "=", "getMaxWorkGroupSGPRCount", "(", "MF", ")", ";", "unsigned", "MaxWorkGroupVGPRCount", "=", "getMaxWorkGroupVGPRCount", "(", "MF", ")", ";", "unsigned", "NumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "unsigned", "NumVGPRs", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "for", "(", "unsigned", "i", "=", "MaxWorkGroupSGPRCount", ";", "i", "<", "NumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "for", "(", "unsigned", "i", "=", "MaxWorkGroupVGPRCount", ";", "i", "<", "NumVGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "ScratchWaveOffsetReg", "=", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ";", "if", "(", "ScratchWaveOffsetReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchWaveOffsetReg", ")", ";", "}", "unsigned", "ScratchRSrcReg", "=", "MFI", "->", "getScratchRSrcReg", "(", ")", ";", "if", "(", "ScratchRSrcReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "ScratchRSrcReg", ")", ";", "assert", "(", "!", "isSubRegister", "(", "ScratchRSrcReg", ",", "ScratchWaveOffsetReg", ")", ")", ";", "}", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "debuggerReserveRegs", "(", ")", ")", "{", "unsigned", "ReservedVGPRFirst", "=", "MaxWorkGroupVGPRCount", "-", "MFI", "->", "getDebuggerReservedVGPRCount", "(", ")", ";", "for", "(", "unsigned", "i", "=", "ReservedVGPRFirst", ";", "i", "<", "MaxWorkGroupVGPRCount", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "VGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "}", "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", "." ]

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::TBA", "AMDGPU::TMA", "AMDGPU::TTMP0_TTMP1", "AMDGPU::TTMP2_TTMP3", "AMDGPU::TTMP4_TTMP5", "AMDGPU::TTMP6_TTMP7", "AMDGPU::TTMP8_TTMP9", "AMDGPU::TTMP10_TTMP11", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "AMDGPU::SGPR_32RegClass", "AMDGPU::VGPR_32RegClass", "SI", "SI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "SI", "SI", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "Relocator", "::", "Size", "ARMRelocator", "::", "getSize", "(", "Relocation", "::", "Type", "pType", ")", "const", "{", "return", "32", ";", "}", "</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", "." ]

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

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "{", "ValidateGV", "(", "GV", ")", ";", "if", "(", "isSpecialLLVMGlobalArrayForStaticInit", "(", "GV", ")", ")", "return", ";", "MCSymbolXCOFF", "*", "GVSym", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "getSymbol", "(", "GV", ")", ")", ";", "GVSym", "->", "setStorageClass", "(", "TargetLoweringObjectFileXCOFF", "::", "getStorageClassForGlobal", "(", "GV", ")", ")", ";", "SectionKind", "GVKind", ";", "MCSectionXCOFF", "*", "Csect", "=", "cast", "<", "MCSectionXCOFF", ">", "(", "GV", "->", "isDeclaration", "(", ")", "?", "getObjFileLowering", "(", ")", ".", "getSectionForExternalReference", "(", "GV", ",", "TM", ")", ":", "getObjFileLowering", "(", ")", ".", "SectionForGlobal", "(", "GV", ",", "GVKind", "=", "getObjFileLowering", "(", ")", ".", "getKindForGlobal", "(", "GV", ",", "TM", ")", ",", "TM", ")", ")", ";", "GVSym", "->", "setContainingCsect", "(", "Csect", ")", ";", "if", "(", "GV", "->", "isDeclaration", "(", ")", ")", "return", ";", "if", "(", "!", "GVKind", ".", "isGlobalWriteableData", "(", ")", "&&", "!", "GVKind", ".", "isReadOnly", "(", ")", ")", "report_fatal_error", "(", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "Csect", ")", ";", "const", "DataLayout", "&", "DL", "=", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "if", "(", "GVKind", ".", "isCommon", "(", ")", "||", "GVKind", ".", "isBSSLocal", "(", ")", ")", "{", "unsigned", "Align", "=", "GV", "->", "getAlignment", "(", ")", "?", "GV", "->", "getAlignment", "(", ")", ":", "DL", ".", "getPreferredAlignment", "(", "GV", ")", ";", "uint64_t", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "GV", "->", "getType", "(", ")", "->", "getElementType", "(", ")", ")", ";", "if", "(", "GVKind", ".", "isBSSLocal", "(", ")", ")", "OutStreamer", "->", "emitXCOFFLocalCommonSymbol", "(", "GVSym", ",", "Size", ",", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Align", ")", ";", "else", "OutStreamer", "->", "emitCommonSymbol", "(", "Csect", "->", "getQualNameSymbol", "(", ")", ",", "Size", ",", "Align", ")", ";", "return", ";", "}", "MCSymbol", "*", "EmittedInitSym", "=", "GVSym", ";", "emitLinkage", "(", "GV", ",", "EmittedInitSym", ")", ";", "emitAlignment", "(", "getGVAlignment", "(", "GV", ",", "DL", ")", ",", "GV", ")", ";", "OutStreamer", "->", "emitLabel", "(", "EmittedInitSym", ")", ";", "emitGlobalConstant", "(", "GV", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ",", "GV", "->", "getInitializer", "(", ")", ")", ";", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "PowerPC", "PPC", "\"Encountered a global variable kind that is \"", "\"not supported yet.\"" ]

[]

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

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "HOST_WIDE_INT", "rs6000_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "rs6000_stack_t", "*", "info", "=", "rs6000_stack_info", "(", ")", ";", "HOST_WIDE_INT", "offset", ";", "if", "(", "from", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "offset", "=", "info", "->", "push_p", "?", "0", ":", "-", "info", "->", "total_size", ";", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "offset", "=", "info", "->", "push_p", "?", "0", ":", "-", "info", "->", "total_size", ";", "if", "(", "FRAME_GROWS_DOWNWARD", ")", "offset", "+=", "info", "->", "fixed_size", "+", "info", "->", "vars_size", "+", "info", "->", "parm_size", ";", "}", "else", "if", "(", "from", "==", "FRAME_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "=", "FRAME_GROWS_DOWNWARD", "?", "info", "->", "fixed_size", "+", "info", "->", "vars_size", "+", "info", "->", "parm_size", ":", "0", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "HARD_FRAME_POINTER_REGNUM", ")", "offset", "=", "info", "->", "total_size", ";", "else", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "offset", "=", "info", "->", "push_p", "?", "info", "->", "total_size", ":", "0", ";", "else", "if", "(", "from", "==", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", "offset", "=", "0", ";", "else", "gcc_unreachable", "(", ")", ";", "return", "offset", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AZPRAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "const", "MachineBasicBlock", "*", "Pred", "=", "*", "MBB", "->", "pred_begin", "(", ")", ";", "MachineBasicBlock", "::", "const_pred_iterator", "PI", "=", "MBB", "->", "pred_begin", "(", ")", ",", "PI2", "=", "PI", ";", "++", "PI2", ";", "if", "(", "PI2", "!=", "MBB", "->", "pred_end", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Pred", "->", "isLayoutSuccessor", "(", "MBB", ")", ")", "return", "false", ";", "if", "(", "Pred", "->", "empty", "(", ")", ")", "return", "true", ";", "MachineBasicBlock", "::", "const_iterator", "I", "=", "Pred", "->", "end", "(", ")", ";", "while", "(", "I", "!=", "Pred", "->", "begin", "(", ")", "&&", "!", "(", "--", "I", ")", "->", "isTerminator", "(", ")", ")", ";", "return", "!", "(", "I", "->", "isBarrier", "(", ")", "||", "(", "I", "->", "getOpcode", "(", ")", "==", "AZPR", "::", "BE", "&&", "I", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "==", "I", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "AZPR", "AZPR", "AZPR::BE", "0", "1" ]

[]

[ "<s>", "static", "bool", "available_occurrence_p", "(", "const", "bb_info", "*", "bb", ",", "const", "vector_insn_info", "dem", ")", "{", "insn_info", "*", "insn", "=", "dem", ".", "get_insn", "(", ")", ";", "if", "(", "dem", ".", "has_avl_reg", "(", ")", ")", "{", "if", "(", "!", "vlmax_avl_p", "(", "dem", ".", "get_avl", "(", ")", ")", ")", "{", "rtx", "dest", "=", "NULL_RTX", ";", "if", "(", "vsetvl_insn_p", "(", "insn", "->", "rtl", "(", ")", ")", ")", "dest", "=", "get_vl", "(", "insn", "->", "rtl", "(", ")", ")", ";", "for", "(", "const", "insn_info", "*", "i", "=", "insn", ";", "real_insn_and_same_bb_p", "(", "i", ",", "bb", ")", ";", "i", "=", "i", "->", "next_nondebug_insn", "(", ")", ")", "{", "if", "(", "read_vl_insn_p", "(", "i", "->", "rtl", "(", ")", ")", ")", "continue", ";", "if", "(", "find_access", "(", "i", "->", "defs", "(", ")", ",", "REGNO", "(", "dem", ".", "get_avl", "(", ")", ")", ")", ")", "return", "false", ";", "if", "(", "dest", "&&", "find_access", "(", "i", "->", "defs", "(", ")", ",", "REGNO", "(", "dest", ")", ")", ")", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "An", "``", "available", "occurrence", "''", "is", "one", "that", "is", "the", "last", "occurrence", "in", "the", "basic", "block", "and", "the", "operands", "are", "not", "modified", "by", "following", "statements", "in", "the", "basic", "block", "[", "including", "this", "insn", "]", ".", "For", "VSETVL", "instruction", ",", "we", "have", "these", "following", "formats", ":", "1.", "vsetvl", "zero", ",", "rs1", ".", "2.", "vsetvl", "zero", ",", "imm", ".", "3.", "vsetvl", "rd", ",", "rs1", ".", "So", "base", "on", "these", "circumstances", ",", "a", "DEM", "is", "considered", "as", "a", "local", "available", "occurrence", "should", "satisfy", "these", "following", "conditions", ":", "1", ")", ".", "rs1", "(", "avl", ")", "are", "not", "modified", "by", "following", "statements", "in", "the", "basic", "block", ".", "2", ")", ".", "rd", "(", "vl", ")", "are", "not", "modified", "by", "following", "statements", "in", "the", "basic", "block", ".", "Note", ":", "We", "do", "n't", "need", "to", "check", "VL/VTYPE", "here", "since", "DEM", "is", "UNKNOWN", "if", "VL/VTYPE", "is", "modified", "prior", "to", "the", "occurrence", ".", "This", "case", "is", "already", "considered", "as", "a", "non-local", "available", "occurrence", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "HexagonBitSimplify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "auto", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "auto", "&", "HRI", "=", "*", "HST", ".", "getRegisterInfo", "(", ")", ";", "auto", "&", "HII", "=", "*", "HST", ".", "getInstrInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "const", "HexagonEvaluator", "HE", "(", "HRI", ",", "MRI", ",", "HII", ",", "MF", ")", ";", "BitTracker", "BT", "(", "HE", ",", "MF", ")", ";", "DEBUG", "(", "BT", ".", "trace", "(", "true", ")", ")", ";", "BT", ".", "run", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "MF", ".", "front", "(", ")", ";", "RegisterSet", "AIG", ";", "ConstGeneration", "ImmG", "(", "BT", ",", "HII", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "ImmG", ",", "AIG", ")", ";", "RegisterSet", "ARE", ";", "RedundantInstrElimination", "RIE", "(", "BT", ",", "HII", ",", "HRI", ",", "MRI", ")", ";", "bool", "Ried", "=", "visitBlock", "(", "Entry", ",", "RIE", ",", "ARE", ")", ";", "if", "(", "Ried", ")", "{", "Changed", "=", "true", ";", "BT", ".", "run", "(", ")", ";", "}", "RegisterSet", "ACG", ";", "CopyGeneration", "CopyG", "(", "BT", ",", "HII", ",", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyG", ",", "ACG", ")", ";", "RegisterSet", "ACP", ";", "CopyPropagation", "CopyP", "(", "HRI", ",", "MRI", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "CopyP", ",", "ACP", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "BT", ".", "run", "(", ")", ";", "RegisterSet", "ABS", ";", "BitSimplification", "BitS", "(", "BT", ",", "*", "MDT", ",", "HII", ",", "HRI", ",", "MRI", ",", "MF", ")", ";", "Changed", "|=", "visitBlock", "(", "Entry", ",", "BitS", ",", "ABS", ")", ";", "Changed", "=", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", "||", "Changed", ";", "if", "(", "Changed", ")", "{", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "I", ".", "clearKillInfo", "(", ")", ";", "DeadCodeElimination", "(", "MF", ",", "*", "MDT", ")", ".", "run", "(", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "PPCTargetMachine", "&", "TM", ",", "bool", "is64Bit", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "IsPPC64", "(", "is64Bit", ")", ",", "TargetTriple", "(", "TT", ")", ",", "OptLevel", "(", "OptLevel", ")", ",", "FrameLowering", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "DL", "(", "getDataLayoutString", "(", "*", "this", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "JITInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ")", ",", "TSInfo", "(", "&", "DL", ")", "{", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

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

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

[ "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "void", "h8300_swap_out_of_er6", "(", "rtx", "addr", ")", "{", "rtx", "insn", ";", "if", "(", "REGNO", "(", "addr", ")", "!=", "SP_REG", ")", "emit_move_insn", "(", "addr", ",", "hard_frame_pointer_rtx", ")", ";", "insn", "=", "pop", "(", "HARD_FRAME_POINTER_REGNUM", ")", ";", "if", "(", "frame_pointer_needed", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "else", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "4", ")", ")", ")", ";", "}", "</s>" ]

[ "Move", "the", "current", "value", "of", "er6", "into", "ADDR", "and", "pop", "its", "old", "value", "from", "the", "stack", "." ]

[ "h8300", "2", "4" ]

[]

[ "<s>", "void", "NVPTXTargetStreamer", "::", "emitRawBytes", "(", "StringRef", "Data", ")", "{", "MCTargetStreamer", "::", "emitRawBytes", "(", "Data", ")", ";", "const", "MCAsmInfo", "*", "MAI", "=", "Streamer", ".", "getContext", "(", ")", ".", "getAsmInfo", "(", ")", ";", "const", "char", "*", "Directive", "=", "MAI", "->", "getData8bitsDirective", "(", ")", ";", "unsigned", "NumElements", "=", "Data", ".", "size", "(", ")", ";", "const", "unsigned", "MaxLen", "=", "40", ";", "unsigned", "NumChunks", "=", "1", "+", "(", "(", "NumElements", "-", "1", ")", "/", "MaxLen", ")", ";", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "NumChunks", ";", "++", "I", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "const", "char", "*", "Label", "=", "Directive", ";", "for", "(", "auto", "It", "=", "std", "::", "next", "(", "Data", ".", "bytes_begin", "(", ")", ",", "I", "*", "MaxLen", ")", ",", "End", "=", "(", "I", "==", "NumChunks", "-", "1", ")", "?", "Data", ".", "bytes_end", "(", ")", ":", "std", "::", "next", "(", "Data", ".", "bytes_begin", "(", ")", ",", "(", "I", "+", "1", ")", "*", "MaxLen", ")", ";", "It", "!=", "End", ";", "++", "It", ")", "{", "OS", "<<", "Label", "<<", "(", "unsigned", ")", "*", "It", ";", "if", "(", "Label", "==", "Directive", ")", "Label", "=", "\",\"", ";", "}", "Streamer", ".", "emitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "the", "bytes", "in", "Data", "into", "the", "output", "." ]

[ "NVPTX", "NVPTX", "40", "1", "1", "0", "128", "1", "1", "\",\"" ]

[]

[ "<s>", "bool", "SNESAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Error", "=", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "if", "(", "Error", "&&", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "if", "(", "ExtraCode", "[", "0", "]", ">=", "'A'", "&&", "ExtraCode", "[", "0", "]", "<=", "'Z'", ")", "{", "const", "MachineOperand", "&", "RegOp", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "RegOp", ".", "isReg", "(", ")", "&&", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", ")", ";", "unsigned", "Reg", "=", "RegOp", ".", "getReg", "(", ")", ";", "unsigned", "ByteNumber", "=", "ExtraCode", "[", "0", "]", "-", "'A'", ";", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "(", "void", ")", "NumOpRegs", ";", "const", "SNESSubtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "SNESSubtarget", ">", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "BytesPerReg", "=", "TRI", ".", "getRegSizeInBits", "(", "*", "RC", ")", "/", "8", ";", "assert", "(", "BytesPerReg", "<=", "2", "&&", "\"Only 8 and 16 bit regs are supported.\"", ")", ";", "unsigned", "RegIdx", "=", "ByteNumber", "/", "BytesPerReg", ";", "assert", "(", "RegIdx", "<", "NumOpRegs", "&&", "\"Multibyte index out of range.\"", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "RegIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "BytesPerReg", "==", "2", ")", "{", "Reg", "=", "TRI", ".", "getSubReg", "(", "Reg", ",", "ByteNumber", "%", "BytesPerReg", "?", "SNES", "::", "sub_hi", ":", "SNES", "::", "sub_lo", ")", ";", "}", "O", "<<", "SNESInstPrinter", "::", "getPrettyRegisterName", "(", "Reg", ",", "MRI", ")", ";", "return", "false", ";", "}", "}", "if", "(", "Error", ")", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "SNES", "SNES", "0", "1", "0", "0", "0", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", "0", "1", "SNES", "SNES", "8", "2", "\"Only 8 and 16 bit regs are supported.\"", "\"Multibyte index out of range.\"", "2", "SNES::sub_hi", "SNES::sub_lo", "SNES" ]

[]

[ "<s>", "static", "tree", "rs6000_fold_builtin", "(", "tree", "fndecl", ",", "int", "n_args", "ATTRIBUTE_UNUSED", ",", "tree", "*", "args", ",", "bool", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "DECL_BUILT_IN_CLASS", "(", "fndecl", ")", "==", "BUILT_IN_MD", ")", "{", "enum", "rs6000_builtins", "fn_code", "=", "(", "enum", "rs6000_builtins", ")", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "switch", "(", "fn_code", ")", "{", "case", "RS6000_BUILTIN_NANQ", ":", "case", "RS6000_BUILTIN_NANSQ", ":", "{", "tree", "type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "const", "char", "*", "str", "=", "c_getstr", "(", "*", "args", ")", ";", "int", "quiet", "=", "fn_code", "==", "RS6000_BUILTIN_NANQ", ";", "REAL_VALUE_TYPE", "real", ";", "if", "(", "str", "&&", "real_nan", "(", "&", "real", ",", "str", ",", "quiet", ",", "TYPE_MODE", "(", "type", ")", ")", ")", "return", "build_real", "(", "type", ",", "real", ")", ";", "return", "NULL_TREE", ";", "}", "case", "RS6000_BUILTIN_INFQ", ":", "case", "RS6000_BUILTIN_HUGE_VALQ", ":", "{", "tree", "type", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "fndecl", ")", ")", ";", "REAL_VALUE_TYPE", "inf", ";", "real_inf", "(", "&", "inf", ")", ";", "return", "build_real", "(", "type", ",", "inf", ")", ";", "}", "default", ":", "break", ";", "}", "}", "return", "SUBTARGET_FOLD_BUILTIN", "(", "fndecl", ",", "n_args", ",", "args", ",", "ignore", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Target", "hook", "for", "early", "folding", "of", "built-ins", ",", "shamelessly", "stolen", "from", "ia64.cc", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "Opcode", "=", "-", "1", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S64_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_S512_SAVE", ";", "break", ";", "}", "}", "else", "if", "(", "shouldTryToSpillVGPRs", "(", "MF", ")", "&&", "RI", ".", "hasVGPRs", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "switch", "(", "RC", "->", "getSize", "(", ")", "*", "8", ")", "{", "case", "32", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V32_SAVE", ";", "break", ";", "case", "64", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V64_SAVE", ";", "break", ";", "case", "96", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V96_SAVE", ";", "break", ";", "case", "128", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V128_SAVE", ";", "break", ";", "case", "256", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V256_SAVE", ";", "break", ";", "case", "512", ":", "Opcode", "=", "AMDGPU", "::", "SI_SPILL_V512_SAVE", ";", "break", ";", "}", "}", "if", "(", "Opcode", "!=", "-", "1", ")", "{", "FrameInfo", "->", "setObjectAlignment", "(", "FrameIndex", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0_SGPR1", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "AMDGPU", "::", "SGPR0", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "KILL", ")", ")", ".", "addReg", "(", "SrcReg", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "SI", "SI", "SI", "1", "8", "32", "SI", "64", "SI", "128", "SI", "256", "SI", "512", "SI", "8", "32", "SI", "64", "SI", "96", "SI", "128", "SI", "256", "SI", "512", "SI", "1", "4", "\"SIInstrInfo::storeRegToStackSlot - Do not know how to\"", "\" spill register\"" ]

[]

[ "<s>", "MCInst", "AArch64InstrInfo", "::", "getNop", "(", ")", "const", "{", "return", "MCInstBuilder", "(", "AArch64", "::", "HINT", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "noop", "instruction", "to", "use", "for", "a", "noop", "." ]

[ "AArch64", "AArch64", "AArch64::HINT", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "AArch64InstrInfo", "::", "insertOutlinedCall", "(", "Module", "&", "M", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "It", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "TargetCostInfo", "&", "TCI", ")", "const", "{", "if", "(", "TCI", ".", "CallConstructionID", "==", "MachineOutlinerTailCall", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "TCRETURNdi", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ".", "addImm", "(", "0", ")", ")", ";", "return", "It", ";", "}", "if", "(", "TCI", ".", "CallConstructionID", "==", "MachineOutlinerNoLRSave", "||", "TCI", ".", "CallConstructionID", "==", "MachineOutlinerThunk", ")", "{", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "BL", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "return", "It", ";", "}", "MachineBasicBlock", "::", "iterator", "CallPt", ";", "MachineInstr", "*", "STRXpre", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "STRXpre", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "-", "16", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "STRXpre", ")", ";", "It", "++", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "BL", ")", ")", ".", "addGlobalAddress", "(", "M", ".", "getNamedValue", "(", "MF", ".", "getName", "(", ")", ")", ")", ")", ";", "CallPt", "=", "It", ";", "It", "++", ";", "MachineInstr", "*", "LDRXpost", "=", "BuildMI", "(", "MF", ",", "DebugLoc", "(", ")", ",", "get", "(", "AArch64", "::", "LDRXpost", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "LR", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "16", ")", ";", "It", "=", "MBB", ".", "insert", "(", "It", ",", "LDRXpost", ")", ";", "return", "CallPt", ";", "}", "</s>" ]

[ "Insert", "a", "call", "to", "an", "outlined", "function", "into", "the", "program", "." ]

[ "AArch64", "AArch64", "AArch64::TCRETURNdi", "0", "AArch64::BL", "AArch64::STRXpre", "AArch64::SP", "AArch64::LR", "AArch64::SP", "16", "AArch64::BL", "AArch64::LDRXpost", "AArch64::SP", "AArch64::LR", "AArch64::SP", "16" ]

[]

[ "<s>", "static", "int", "rs6000_emit_p9_fp_minmax", "(", "rtx", "dest", ",", "rtx", "op", ",", "rtx", "true_cond", ",", "rtx", "false_cond", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "op", ")", ";", "rtx", "op0", "=", "XEXP", "(", "op", ",", "0", ")", ";", "rtx", "op1", "=", "XEXP", "(", "op", ",", "1", ")", ";", "machine_mode", "compare_mode", "=", "GET_MODE", "(", "op0", ")", ";", "machine_mode", "result_mode", "=", "GET_MODE", "(", "dest", ")", ";", "bool", "max_p", "=", "false", ";", "if", "(", "result_mode", "!=", "compare_mode", ")", "return", "0", ";", "if", "(", "code", "==", "GE", "||", "code", "==", "GT", ")", "max_p", "=", "true", ";", "else", "if", "(", "code", "==", "LE", "||", "code", "==", "LT", ")", "max_p", "=", "false", ";", "else", "return", "0", ";", "if", "(", "rtx_equal_p", "(", "op0", ",", "true_cond", ")", "&&", "rtx_equal_p", "(", "op1", ",", "false_cond", ")", ")", ";", "else", "if", "(", "rtx_equal_p", "(", "op1", ",", "true_cond", ")", "&&", "rtx_equal_p", "(", "op0", ",", "false_cond", ")", ")", "max_p", "=", "!", "max_p", ";", "else", "return", "0", ";", "rs6000_emit_minmax", "(", "dest", ",", "max_p", "?", "SMAX", ":", "SMIN", ",", "op0", ",", "op1", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "ISA", "3.0", "(", "power9", ")", "minmax", "subcase", "to", "emit", "a", "XSMAXCDP", "or", "XSMINCDP", "instruction", "for", "SF/DF", "scalars", ".", "Move", "TRUE_COND", "to", "DEST", "if", "OP", "of", "the", "operands", "of", "the", "last", "comparison", "is", "nonzero/true", ",", "FALSE_COND", "if", "it", "is", "zero/false", ".", "Return", "0", "if", "the", "hardware", "has", "no", "such", "operation", "." ]

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

[]

[ "<s>", "static", "tree", "sh_symbian_associated_type", "(", "tree", "decl", ")", "{", "tree", "t", "=", "NULL_TREE", ";", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "decl", ")", ")", "==", "METHOD_TYPE", ")", "return", "t", ";", "if", "(", "DECL_CONTEXT", "(", "decl", ")", "&&", "TYPE_P", "(", "DECL_CONTEXT", "(", "decl", ")", ")", ")", "t", "=", "DECL_CONTEXT", "(", "decl", ")", ";", "return", "t", ";", "}", "</s>" ]

[ "Return", "the", "type", "that", "we", "should", "use", "to", "determine", "if", "DECL", "is", "imported", "or", "exported", "." ]

[ "sh" ]

[]

[ "<s>", "bool", "aarch64_float_const_representable_p", "(", "rtx", "x", ")", "{", "int", "point_pos", "=", "2", "*", "HOST_BITS_PER_WIDE_INT", "-", "1", ";", "int", "exponent", ";", "unsigned", "HOST_WIDE_INT", "mantissa", ",", "mask", ";", "REAL_VALUE_TYPE", "r", ",", "m", ";", "bool", "fail", ";", "x", "=", "unwrap_const_vec_duplicate", "(", "x", ")", ";", "if", "(", "!", "CONST_DOUBLE_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "||", "(", "GET_MODE", "(", "x", ")", "==", "HFmode", "&&", "!", "TARGET_FP_F16INST", ")", ")", "return", "false", ";", "r", "=", "*", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ";", "if", "(", "REAL_VALUE_ISINF", "(", "r", ")", "||", "REAL_VALUE_ISNAN", "(", "r", ")", "||", "REAL_VALUE_MINUS_ZERO", "(", "r", ")", ")", "return", "false", ";", "r", "=", "real_value_abs", "(", "&", "r", ")", ";", "exponent", "=", "REAL_EXP", "(", "&", "r", ")", ";", "real_ldexp", "(", "&", "m", ",", "&", "r", ",", "point_pos", "-", "exponent", ")", ";", "wide_int", "w", "=", "real_to_integer", "(", "&", "m", ",", "&", "fail", ",", "HOST_BITS_PER_WIDE_INT", "*", "2", ")", ";", "if", "(", "w", ".", "ulow", "(", ")", "!=", "0", ")", "return", "false", ";", "mantissa", "=", "w", ".", "elt", "(", "1", ")", ";", "point_pos", "-=", "HOST_BITS_PER_WIDE_INT", ";", "mask", "=", "(", "(", "unsigned", "HOST_WIDE_INT", ")", "1", "<<", "(", "point_pos", "-", "5", ")", ")", "-", "1", ";", "if", "(", "(", "mantissa", "&", "mask", ")", "!=", "0", ")", "return", "false", ";", "mantissa", ">>=", "point_pos", "-", "5", ";", "if", "(", "mantissa", "==", "0", ")", "return", "false", ";", "mantissa", "&=", "~", "(", "1", "<<", "4", ")", ";", "gcc_assert", "(", "mantissa", "<=", "15", ")", ";", "exponent", "=", "5", "-", "exponent", ";", "return", "(", "exponent", ">=", "0", "&&", "exponent", "<=", "7", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "X", "can", "be", "represented", "by", "a", "quarter-precision", "floating", "point", "immediate", "operand", "X", ".", "Note", ",", "we", "can", "not", "represent", "0.0", "." ]

[ "aarch64", "2", "1", "2", "0", "1", "1", "5", "1", "0", "5", "0", "1", "4", "15", "5", "0", "7" ]

[]

[ "<s>", "static", "void", "annotate_constant_pool_refs", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "s390_safe_relative_long_p", "(", "insn", ")", ")", "return", ";", "annotate_constant_pool_refs_1", "(", "&", "PATTERN", "(", "insn", ")", ")", ";", "}", "</s>" ]

[ "Annotate", "every", "literal", "pool", "reference", "in", "X", "by", "an", "UNSPEC_LTREF", "expression", ".", "Fix", "up", "MEMs", "as", "required", "." ]

[ "s390" ]

[]

[ "<s>", "static", "inline", "long", "long", "load_byte", "(", "void", "*", "skb", "__attribute__", "(", "(", "unused", ")", ")", ",", "unsigned", "long", "long", "off", ")", "{", "return", "__builtin_bpf_load_byte", "(", "off", ")", ";", "}", "</s>" ]

[ "Functions", "to", "emit", "BPF_LD_ABS", "and", "BPF_LD_IND", "instructions", ".", "We", "provide", "the", "``", "standard", "''", "names", "as", "synonyms", "of", "the", "corresponding", "GCC", "builtins", ".", "Note", "how", "the", "SKB", "argument", "is", "ignored", "." ]

[ "bpf" ]

[]

[ "<s>", "void", "s390_d_target_versions", "(", "void", ")", "{", "if", "(", "TARGET_64BIT", ")", "{", "d_add_builtin_version", "(", "\"S390X\"", ")", ";", "d_add_builtin_version", "(", "\"SystemZ\"", ")", ";", "}", "else", "d_add_builtin_version", "(", "\"S390\"", ")", ";", "if", "(", "TARGET_SOFT_FLOAT", ")", "d_add_builtin_version", "(", "\"D_SoftFloat\"", ")", ";", "else", "if", "(", "TARGET_HARD_FLOAT", ")", "d_add_builtin_version", "(", "\"D_HardFloat\"", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_D_CPU_VERSIONS", "for", "S/390", "and", "zSeries", "targets", "." ]

[ "s390", "\"S390X\"", "\"SystemZ\"", "\"S390\"", "\"D_SoftFloat\"", "\"D_HardFloat\"" ]

[]

[ "<s>", "static", "bool", "mips_orphaned_high_part_p", "(", "mips_offset_table", "*", "htab", ",", "rtx_insn", "*", "insn", ")", "{", "enum", "mips_symbol_type", "type", ";", "rtx", "x", ",", "set", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", ")", "{", "x", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", "&&", "absolute_symbolic_operand", "(", "XEXP", "(", "x", ",", "0", ")", ",", "VOIDmode", ")", ")", "return", "!", "mips_lo_sum_offset_lookup", "(", "htab", ",", "XEXP", "(", "x", ",", "0", ")", ",", "NO_INSERT", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_LOAD_GOT", "&&", "mips_symbolic_constant_p", "(", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ",", "SYMBOL_CONTEXT_LEA", ",", "&", "type", ")", "&&", "type", "==", "SYMBOL_GOTOFF_PAGE", ")", "return", "!", "mips_lo_sum_offset_lookup", "(", "htab", ",", "XVECEXP", "(", "x", ",", "0", ",", "1", ")", ",", "NO_INSERT", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "a", "SET", "of", "an", "orphaned", "high-part", "relocation", ".", "HTAB", "is", "a", "hash", "table", "of", "mips_lo_sum_offsets", "that", "describes", "all", "the", "LO_SUMs", "in", "the", "current", "function", "." ]

[ "mips", "0", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "getRegForGEPIndex", "(", "const", "Value", "*", "Idx", ")", "{", "Register", "IdxN", "=", "getRegForValue", "(", "Idx", ")", ";", "if", "(", "IdxN", "==", "0", ")", "return", "0", ";", "MVT", "PtrVT", "=", "TLI", ".", "getPointerTy", "(", "DL", ")", ";", "EVT", "IdxVT", "=", "EVT", "::", "getEVT", "(", "Idx", "->", "getType", "(", ")", ",", "false", ")", ";", "if", "(", "IdxVT", ".", "bitsLT", "(", "PtrVT", ")", ")", "{", "IdxN", "=", "emitIntExt", "(", "IdxVT", ".", "getSimpleVT", "(", ")", ",", "IdxN", ",", "PtrVT", ",", "false", ")", ";", "}", "else", "if", "(", "IdxVT", ".", "bitsGT", "(", "PtrVT", ")", ")", "llvm_unreachable", "(", "\"AArch64 FastISel doesn't support types larger than i64\"", ")", ";", "return", "IdxN", ";", "}", "</s>" ]

[ "This", "is", "a", "wrapper", "around", "getRegForValue", "that", "also", "takes", "care", "of", "truncating", "or", "sign-extending", "the", "given", "getelementptr", "index", "value", "." ]

[ "AArch64", "AArch64", "0", "0", "\"AArch64 FastISel doesn't support types larger than i64\"" ]

[]

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

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

[ "mips" ]

[]

[ "<s>", "void", "P2InstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "DebugLoc", "DL", "=", "I", "!=", "MBB", ".", "end", "(", ")", "?", "I", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "unsigned", "inst", "=", "P2", "::", "ADDri", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"adjust stack pointer by \"", "<<", "amount", "<<", "\"\\n\"", ")", ";", "if", "(", "amount", "<", "0", ")", "{", "inst", "=", "P2", "::", "SUBri", ";", "amount", "=", "-", "amount", ";", "}", "if", "(", "isInt", "<", "32", ">", "(", "amount", ")", ")", "{", "if", "(", "!", "isInt", "<", "9", ">", "(", "amount", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "P2", "::", "AUGS", ")", ")", ".", "addImm", "(", "amount", ">>", "9", ")", ";", "}", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "inst", ")", ",", "SP", ")", ".", "addReg", "(", "SP", ")", ".", "addImm", "(", "amount", "&", "0x1ff", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot adjust stack pointer by more than 32 bits (and adjusting by more than 20 bits never makes sense!)\"", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "P2", "P2", "P2::ADDri", "\"adjust stack pointer by \"", "\"\\n\"", "0", "P2::SUBri", "32", "9", "P2::AUGS", "9", "0x1ff", "\"Cannot adjust stack pointer by more than 32 bits (and adjusting by more than 20 bits never makes sense!)\"" ]

[]

[ "<s>", "int", "mn10300_symbolic_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "1", ";", "case", "CONST", ":", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "1", "if", "X", "contains", "a", "symbolic", "expression", ".", "We", "know", "these", "expressions", "will", "have", "one", "of", "a", "few", "well", "defined", "forms", ",", "so", "we", "need", "only", "check", "those", "forms", "." ]

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

[]

[ "<s>", "bool", "X86InstrInfo", "::", "hasCommutePreference", "(", "MachineInstr", "&", "MI", ",", "bool", "&", "Commute", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "!=", "X86", "::", "ADD32rr", "&&", "Opcode", "!=", "X86", "::", "ADD64rr", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "Register", "Reg1", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "Register", "Reg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "if", "(", "MachineInstr", "*", "Inst", "=", "MRI", ".", "getUniqueVRegDef", "(", "Reg1", ")", ")", "{", "if", "(", "isConvertibleLEA", "(", "Inst", ")", "&&", "Inst", "->", "getParent", "(", ")", "==", "MI", ".", "getParent", "(", ")", ")", "{", "Commute", "=", "true", ";", "return", "true", ";", "}", "}", "if", "(", "MachineInstr", "*", "Inst", "=", "MRI", ".", "getUniqueVRegDef", "(", "Reg2", ")", ")", "{", "if", "(", "isConvertibleLEA", "(", "Inst", ")", "&&", "Inst", "->", "getParent", "(", ")", "==", "MI", ".", "getParent", "(", ")", ")", "{", "Commute", "=", "false", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "we", "have", "preference", "on", "the", "operands", "order", "in", "MI", ",", "the", "commute", "decision", "is", "returned", "in", "Commute", "." ]

[ "X86", "X86", "X86::ADD32rr", "X86::ADD64rr", "1", "2" ]

[]

[ "<s>", "void", "emitGlobalVariable", "(", "const", "GlobalVariable", "*", "GV", ")", "override", "{", "}", "</s>" ]

[ "Emit", "the", "specified", "global", "variable", "to", "the", ".s", "file", "." ]

[ "NVPTX" ]

[]