Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "int", "is_regular_file", "(", "char", "*", "name", ")", "{", "int", "ret", ";", "struct", "stat", "statbuf", ";", "ret", "=", "stat", "(", "name", ",", "&", "statbuf", ")", ";", "return", "!", "ret", "&&", "S_ISREG", "(", "statbuf", ".", "st_mode", ")", ";", "}", "</s>" ]

[ "Check", "to", "see", "if", "NAME", "is", "a", "regular", "file", ",", "i.e", ".", "not", "a", "directory", "." ]

[ "vms" ]

[]

[ "<s>", "bool", "MSP430TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createMSP430BranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addIRPasses", "(", ")", "{", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "os16", "(", ")", ")", "addPass", "(", "createMipsOs16", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getMipsSubtarget", "(", ")", ".", "inMips16HardFloat", "(", ")", ")", "addPass", "(", "createMips16HardFloat", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createMipsOptimizeMathLibCalls", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "SparcFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "Register", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ".", "getFixed", "(", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", "||", "!", "Subtarget", ".", "hasHardQuad", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STQFri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Register", "SrcEvenReg", "=", "getSubReg", "(", "SrcReg", ",", "SP", "::", "sub_even64", ")", ";", "Register", "SrcOddReg", "=", "getSubReg", "(", "SrcReg", ",", "SP", "::", "sub_odd64", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcEvenReg", ")", ";", "replaceFI", "(", "MF", ",", "*", "StMI", ",", "*", "StMI", ",", "dl", ",", "0", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "SP", "::", "STDFri", ")", ")", ";", "MI", ".", "getOperand", "(", "2", ")", ".", "setReg", "(", "SrcOddReg", ")", ";", "Offset", "+=", "8", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "LDQFri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "DestEvenReg", "=", "getSubReg", "(", "DestReg", ",", "SP", "::", "sub_even64", ")", ";", "Register", "DestOddReg", "=", "getSubReg", "(", "DestReg", ",", "SP", "::", "sub_odd64", ")", ";", "MachineInstr", "*", "LdMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestEvenReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ";", "replaceFI", "(", "MF", ",", "*", "LdMI", ",", "*", "LdMI", ",", "dl", ",", "1", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "SP", "::", "LDDFri", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestOddReg", ")", ";", "Offset", "+=", "8", ";", "}", "}", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "Sparc", "Sparc", "Sparc", "1", "SP::STQFri", "2", "SP::sub_even64", "SP::sub_odd64", "SP::STDFri", "0", "0", "SP::STDFri", "2", "8", "SP::LDQFri", "0", "SP::sub_even64", "SP::sub_odd64", "SP::LDDFri", "0", "1", "SP::LDDFri", "0", "8" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isSchedulingBoundary", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineBasicBlock", "*", "MBB", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "TargetInstrInfo", "::", "isSchedulingBoundary", "(", "MI", ",", "MBB", ",", "MF", ")", ")", "return", "true", ";", "return", "isSEHInstruction", "(", "MI", ")", ";", "}", "</s>" ]

[ "isSchedulingBoundary", "-", "Overrides", "the", "isSchedulingBoundary", "from", "Codegen/TargetInstrInfo.cpp", "to", "make", "it", "capable", "of", "identifying", "ENDBR", "intructions", "and", "prevent", "it", "from", "being", "re-scheduled", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "TBB", "=", "nullptr", ";", "FBB", "=", "nullptr", ";", "MachineBasicBlock", "::", "instr_iterator", "I", "=", "MBB", ".", "instr_end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "while", "(", "isPredicated", "(", "*", "I", ")", "||", "I", "->", "isTerminator", "(", ")", "||", "I", "->", "isDebugValue", "(", ")", ")", "{", "bool", "CantAnalyze", "=", "false", ";", "while", "(", "I", "->", "isDebugInstr", "(", ")", "||", "!", "I", "->", "isTerminator", "(", ")", "||", "isSpeculationBarrierEndBBOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2DoLoopStartTP", ")", "{", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "if", "(", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "if", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "}", "else", "if", "(", "isCondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "!", "Cond", ".", "empty", "(", ")", ")", "return", "true", ";", "assert", "(", "!", "FBB", "&&", "\"FBB should have been null.\"", ")", ";", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "I", "->", "getOperand", "(", "2", ")", ")", ";", "}", "else", "if", "(", "I", "->", "isReturn", "(", ")", ")", "{", "CantAnalyze", "=", "true", ";", "}", "else", "{", "return", "true", ";", "}", "if", "(", "!", "isPredicated", "(", "*", "I", ")", "&&", "(", "isUncondBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isIndirectBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "isJumpTableBranchOpcode", "(", "I", "->", "getOpcode", "(", ")", ")", "||", "I", "->", "isReturn", "(", ")", ")", ")", "{", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "AllowModify", ")", "{", "MachineBasicBlock", "::", "iterator", "DI", "=", "std", "::", "next", "(", "I", ")", ";", "while", "(", "DI", "!=", "MBB", ".", "instr_end", "(", ")", ")", "{", "MachineInstr", "&", "InstToDelete", "=", "*", "DI", ";", "++", "DI", ";", "if", "(", "isSpeculationBarrierEndBBOpcode", "(", "InstToDelete", ".", "getOpcode", "(", ")", ")", ")", "continue", ";", "InstToDelete", ".", "eraseFromParent", "(", ")", ";", "}", "}", "}", "if", "(", "CantAnalyze", ")", "{", "if", "(", "AllowModify", "&&", "!", "isPredicated", "(", "MBB", ".", "back", "(", ")", ")", "&&", "isUncondBranchOpcode", "(", "MBB", ".", "back", "(", ")", ".", "getOpcode", "(", ")", ")", "&&", "TBB", "&&", "MBB", ".", "isLayoutSuccessor", "(", "TBB", ")", ")", "removeBranch", "(", "MBB", ")", ";", "return", "true", ";", "}", "if", "(", "I", "==", "MBB", ".", "instr_begin", "(", ")", ")", "return", "false", ";", "--", "I", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "ARM", "ARM", "ARM::t2DoLoopStartTP", "0", "\"FBB should have been null.\"", "0", "1", "2" ]

[]

[ "<s>", "void", "mprocInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "llvm_unreachable", "(", "\"Cannot store this register to stack slot!\"", ")", ";", "}", "</s>" ]

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

[ "mproc", "mproc", "\"Cannot store this register to stack slot!\"" ]

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isPredicable", "(", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "return", "STI", ".", "hasLoadStoreOnCond", "(", ")", "&&", "getConditionalMove", "(", "Opcode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNo", ",", "AsmVariant", ",", "ExtraCode", ",", "OS", ")", ";", "case", "'c'", ":", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "case", "'L'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", "||", "OpNo", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNo", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNo", ";", "break", ";", "case", "'I'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isImm", "(", ")", ")", "OS", "<<", "\"i\"", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ",", "OS", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "1", "0", "0", "1", "1", "\"i\"" ]

[]

[ "<s>", "static", "tree", "epiphany_handle_interrupt_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "value", ";", "if", "(", "!", "args", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "tree", "t", "=", "TREE_TYPE", "(", "*", "node", ")", ";", "if", "(", "TREE_CODE", "(", "t", ")", "!=", "FUNCTION_TYPE", ")", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "else", "if", "(", "TYPE_ARG_TYPES", "(", "t", ")", "&&", "TREE_VALUE", "(", "TYPE_ARG_TYPES", "(", "t", ")", ")", "!=", "void_type_node", ")", "error_at", "(", "DECL_SOURCE_LOCATION", "(", "*", "node", ")", ",", "\"interrupt handlers cannot have arguments\"", ")", ";", "return", "NULL_TREE", ";", "}", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"reset\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"software_exception\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"page_miss\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"timer0\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"timer1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"message\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"dma0\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"dma1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"wand\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"swi\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not %qs, %qs %qs, %qs, %qs, \"", "\"%qs, %qs, %qs, %qs or %qs\"", ",", "name", ",", "\"reset\"", ",", "\"software_exception\"", ",", "\"page_miss\"", ",", "\"timer0\"", ",", "\"timer1\"", ",", "\"message\"", ",", "\"dma0\"", ",", "\"dma1\"", ",", "\"wand\"", ",", "\"swi\"", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "}", "return", "epiphany_handle_interrupt_attribute", "(", "node", ",", "name", ",", "TREE_CHAIN", "(", "args", ")", ",", "flags", ",", "no_add_attrs", ")", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "epiphany", "\"%qE attribute only applies to functions\"", "\"interrupt handlers cannot have arguments\"", "\"argument of %qE attribute is not a string constant\"", "\"reset\"", "\"software_exception\"", "\"page_miss\"", "\"timer0\"", "\"timer1\"", "\"message\"", "\"dma0\"", "\"dma1\"", "\"wand\"", "\"swi\"", "\"argument of %qE attribute is not %qs, %qs %qs, %qs, %qs, \"", "\"%qs, %qs, %qs, %qs or %qs\"", "\"reset\"", "\"software_exception\"", "\"page_miss\"", "\"timer0\"", "\"timer1\"", "\"message\"", "\"dma0\"", "\"dma1\"", "\"wand\"", "\"swi\"" ]

[]

[ "<s>", "void", "SIRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", "->", "getParent", "(", ")", ";", "const", "GCNSubtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "bool", "SeenFI", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isFI", "(", ")", ")", "{", "if", "(", "SeenFI", ")", "llvm_unreachable", "(", "\"should not see multiple frame indices\"", ")", ";", "SeenFI", "=", "true", ";", "}", "}", "MachineOperand", "*", "FIOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ";", "assert", "(", "FIOp", "&&", "FIOp", "->", "isFI", "(", ")", "&&", "\"frame index must be address operand\"", ")", ";", "assert", "(", "TII", "->", "isMUBUF", "(", "MI", ")", ")", ";", "assert", "(", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", "->", "getReg", "(", ")", "==", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", "->", "getStackPtrOffsetReg", "(", ")", "&&", "\"should only be seeing stack pointer offset relative FrameIndex\"", ")", ";", "MachineOperand", "*", "OffsetOp", "=", "TII", "->", "getNamedOperand", "(", "MI", ",", "AMDGPU", "::", "OpName", "::", "offset", ")", ";", "int64_t", "NewOffset", "=", "OffsetOp", "->", "getImm", "(", ")", "+", "Offset", ";", "assert", "(", "isUInt", "<", "12", ">", "(", "NewOffset", ")", "&&", "\"offset should be legal\"", ")", ";", "FIOp", "->", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "OffsetOp", "->", "setImm", "(", "NewOffset", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "AMDGPU", "SI", "SI", "\"should not see multiple frame indices\"", "AMDGPU::OpName", "\"frame index must be address operand\"", "AMDGPU::OpName", "SI", "\"should only be seeing stack pointer offset relative FrameIndex\"", "AMDGPU::OpName", "12", "\"offset should be legal\"" ]

[]

[ "<s>", "void", "optimization_options", "(", "int", "level", ",", "int", "size", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "level", ">", "1", ")", "flag_schedule_insns", "=", "0", ";", "if", "(", "TARGET_MACHO", ")", "flag_errno_math", "=", "0", ";", "if", "(", "optimize", ">=", "1", ")", "flag_omit_frame_pointer", "=", "2", ";", "flag_pcc_struct_return", "=", "2", ";", "flag_asynchronous_unwind_tables", "=", "2", ";", "SUBTARGET_OPTIMIZATION_OPTIONS", ";", "}", "</s>" ]

[ "Change", "optimizations", "to", "be", "performed", ",", "depending", "on", "the", "optimization", "level", ".", "LEVEL", "is", "the", "optimization", "level", "specified", ";", "2", "if", "`", "-O2", "'", "is", "specified", ",", "1", "if", "`", "-O", "'", "is", "specified", ",", "and", "0", "if", "neither", "is", "specified", ".", "SIZE", "is", "nonzero", "if", "`", "-Os", "'", "is", "specified", "and", "zero", "otherwise", "." ]

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

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "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", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_PPC", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ")", ";", "}", "SDValue", "Flag", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "}", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "Flag", ")", ";", "else", "return", "DAG", ".", "getNode", "(", "PPCISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "ISD::OutputArg", "16", "PPC", "0", "0", "\"Can only return in registers!\"", "1", "PPCISD::RET_FLAG", "MVT::Other", "PPCISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "th_mempair_operands_p", "(", "rtx", "operands", "[", "4", "]", ",", "bool", "load_p", ",", "machine_mode", "mode", ")", "{", "rtx", "mem_1", ",", "mem_2", ",", "reg_1", ",", "reg_2", ";", "if", "(", "load_p", ")", "{", "reg_1", "=", "operands", "[", "0", "]", ";", "mem_1", "=", "operands", "[", "1", "]", ";", "reg_2", "=", "operands", "[", "2", "]", ";", "mem_2", "=", "operands", "[", "3", "]", ";", "if", "(", "!", "REG_P", "(", "reg_1", ")", "||", "!", "REG_P", "(", "reg_2", ")", ")", "return", "false", ";", "if", "(", "th_mempair_load_overlap_p", "(", "reg_1", ",", "reg_2", ",", "mem_1", ")", ")", "return", "false", ";", "if", "(", "th_mempair_load_overlap_p", "(", "reg_1", ",", "reg_2", ",", "mem_2", ")", ")", "return", "false", ";", "}", "else", "{", "mem_1", "=", "operands", "[", "0", "]", ";", "reg_1", "=", "operands", "[", "1", "]", ";", "mem_2", "=", "operands", "[", "2", "]", ";", "reg_2", "=", "operands", "[", "3", "]", ";", "}", "if", "(", "!", "REG_P", "(", "reg_1", ")", "||", "!", "GP_REG_P", "(", "REGNO", "(", "reg_1", ")", ")", "||", "!", "REG_P", "(", "reg_2", ")", "||", "!", "GP_REG_P", "(", "REGNO", "(", "reg_2", ")", ")", ")", "return", "false", ";", "if", "(", "!", "MEM_P", "(", "mem_1", ")", "||", "!", "MEM_P", "(", "mem_2", ")", ")", "return", "false", ";", "if", "(", "MEM_VOLATILE_P", "(", "mem_1", ")", "||", "MEM_VOLATILE_P", "(", "mem_2", ")", ")", "return", "false", ";", "if", "(", "riscv_slow_unaligned_access_p", "&&", "known_lt", "(", "MEM_ALIGN", "(", "mem_1", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", "*", "BITS_PER_UNIT", ")", ")", "return", "false", ";", "bool", "reversed", "=", "false", ";", "if", "(", "!", "th_mempair_check_consecutive_mems", "(", "mode", ",", "&", "mem_1", ",", "&", "mem_2", ",", "&", "reversed", ")", ")", "return", "false", ";", "if", "(", "(", "!", "reversed", "&&", "!", "th_mempair_operand_p", "(", "mem_1", ",", "mode", ")", ")", "||", "(", "reversed", "&&", "!", "th_mempair_operand_p", "(", "mem_2", ",", "mode", ")", ")", ")", "return", "false", ";", "gcc_assert", "(", "known_eq", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem_1", ")", ")", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem_2", ")", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", ",", "check", "if", "we", "can", "merge", "them", "into", "load-pair", "or", "store-pair", "instructions", ".", "LOAD", "is", "true", "if", "they", "are", "load", "instructions", ".", "MODE", "is", "the", "mode", "of", "memory", "operation", "." ]

[ "riscv", "4", "0", "1", "2", "3", "0", "1", "2", "3" ]

[]

[ "<s>", "bool", "TPCAsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "static", "tree", "gen_stdcall_or_fastcall_suffix", "(", "tree", "decl", ",", "tree", "id", ",", "bool", "fastcall", ")", "{", "HOST_WIDE_INT", "total", "=", "0", ";", "const", "char", "*", "old_str", "=", "IDENTIFIER_POINTER", "(", "id", "!=", "NULL_TREE", "?", "id", ":", "DECL_NAME", "(", "decl", ")", ")", ";", "char", "*", "new_str", ",", "*", "p", ";", "tree", "type", "=", "TREE_TYPE", "(", "DECL_ORIGIN", "(", "decl", ")", ")", ";", "tree", "arg", ";", "function_args_iterator", "args_iter", ";", "gcc_assert", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", ";", "if", "(", "prototype_p", "(", "type", ")", ")", "{", "if", "(", "stdarg_p", "(", "type", ")", ")", "return", "NULL_TREE", ";", "FOREACH_FUNCTION_ARGS", "(", "type", ",", "arg", ",", "args_iter", ")", "{", "HOST_WIDE_INT", "parm_size", ";", "HOST_WIDE_INT", "parm_boundary_bytes", "=", "PARM_BOUNDARY", "/", "BITS_PER_UNIT", ";", "if", "(", "!", "COMPLETE_TYPE_P", "(", "arg", ")", ")", "break", ";", "parm_size", "=", "int_size_in_bytes", "(", "arg", ")", ";", "if", "(", "parm_size", "<", "0", ")", "break", ";", "parm_size", "=", "(", "(", "parm_size", "+", "parm_boundary_bytes", "-", "1", ")", "/", "parm_boundary_bytes", "*", "parm_boundary_bytes", ")", ";", "total", "+=", "parm_size", ";", "}", "}", "p", "=", "new_str", "=", "XALLOCAVEC", "(", "char", ",", "1", "+", "strlen", "(", "old_str", ")", "+", "1", "+", "8", "+", "1", ")", ";", "if", "(", "fastcall", ")", "*", "p", "++", "=", "FASTCALL_PREFIX", ";", "sprintf", "(", "p", ",", "\"%s@\"", "HOST_WIDE_INT_PRINT_DEC", ",", "old_str", ",", "total", ")", ";", "return", "get_identifier", "(", "new_str", ")", ";", "}", "</s>" ]

[ "Return", "string", "which", "is", "the", "former", "assembler", "name", "modified", "with", "a", "suffix", "consisting", "of", "an", "atsign", "(", "@", ")", "followed", "by", "the", "number", "of", "bytes", "of", "arguments", ".", "If", "FASTCALL", "is", "true", ",", "also", "add", "the", "FASTCALL_PREFIX", "." ]

[ "i386", "0", "0", "1", "1", "1", "8", "1", "\"%s@\"" ]

[]

[ "<s>", "static", "inline", "HOST_WIDE_INT", "htm_spr_num", "(", "enum", "rs6000_builtins", "code", ")", "{", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFHAR", "||", "code", "==", "HTM_BUILTIN_SET_TFHAR", ")", "return", "TFHAR_SPR", ";", "else", "if", "(", "code", "==", "HTM_BUILTIN_GET_TFIAR", "||", "code", "==", "HTM_BUILTIN_SET_TFIAR", ")", "return", "TFIAR_SPR", ";", "else", "if", "(", "code", "==", "HTM_BUILTIN_GET_TEXASR", "||", "code", "==", "HTM_BUILTIN_SET_TEXASR", ")", "return", "TEXASR_SPR", ";", "gcc_assert", "(", "code", "==", "HTM_BUILTIN_GET_TEXASRU", "||", "code", "==", "HTM_BUILTIN_SET_TEXASRU", ")", ";", "return", "TEXASRU_SPR", ";", "}", "</s>" ]

[ "Return", "the", "appropriate", "SPR", "number", "associated", "with", "the", "given", "builtin", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "SP", "::", "IntRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "ORrr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SP", "::", "G0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "SP", "::", "FPRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "FMOVS", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "if", "(", "SP", "::", "DFPRegsRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Subtarget", ".", "isV9", "(", ")", "?", "SP", "::", "FMOVD", ":", "SP", "::", "FpMOVD", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::IntRegsRegClass", "SP::ORrr", "SP::G0", "SP::FPRegsRegClass", "SP::FMOVS", "SP::DFPRegsRegClass", "SP::FMOVD", "SP::FpMOVD", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "int", "call_insn_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "rtx", "inside", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "register_operand", "(", "inside", ",", "Pmode", ")", ")", "return", "1", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "inside", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Test", "for", "a", "valid", "operand", "for", "a", "call", "instruction", ".", "Do", "n't", "allow", "the", "arg", "pointer", "register", "or", "virtual", "regs", "since", "they", "may", "change", "into", "reg", "+", "const", ",", "which", "the", "patterns", "ca", "n't", "handle", "yet", "." ]

[ "avr", "0", "1", "1", "0" ]

[]

[ "<s>", "static", "void", "nvptx_call_args", "(", "rtx", "arg", ",", "tree", "fntype", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "doing_call", ")", "{", "cfun", "->", "machine", "->", "doing_call", "=", "true", ";", "cfun", "->", "machine", "->", "is_varadic", "=", "false", ";", "cfun", "->", "machine", "->", "num_args", "=", "0", ";", "if", "(", "fntype", "&&", "stdarg_p", "(", "fntype", ")", ")", "{", "cfun", "->", "machine", "->", "is_varadic", "=", "true", ";", "cfun", "->", "machine", "->", "has_varadic", "=", "true", ";", "cfun", "->", "machine", "->", "num_args", "++", ";", "}", "}", "if", "(", "REG_P", "(", "arg", ")", "&&", "arg", "!=", "pc_rtx", ")", "{", "cfun", "->", "machine", "->", "num_args", "++", ";", "cfun", "->", "machine", "->", "call_args", "=", "alloc_EXPR_LIST", "(", "VOIDmode", ",", "arg", ",", "cfun", "->", "machine", "->", "call_args", ")", ";", "}", "}", "</s>" ]

[ "Implement", "the", "TARGET_CALL_ARGS", "hook", ".", "Record", "information", "about", "one", "argument", "to", "the", "next", "call", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "SDValue", "getInstr", "(", "unsigned", "MachineOpc", ",", "const", "SDLoc", "&", "dl", ",", "MVT", "Ty", ",", "ArrayRef", "<", "SDValue", ">", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDNode", "*", "N", "=", "DAG", ".", "getMachineNode", "(", "MachineOpc", ",", "dl", ",", "Ty", ",", "Ops", ")", ";", "return", "SDValue", "(", "N", ",", "0", ")", ";", "}", "</s>" ]

[ "Returns", "the", "representative", "MachineInstr", "for", "this", "SUnit", "." ]

[ "Hexagon", "0" ]

[]

[ "<s>", "MachineBasicBlock", "*", "NyuziTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "&", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "Nyuzi", "::", "SELECTI", ":", "case", "Nyuzi", "::", "SELECTF", ":", "case", "Nyuzi", "::", "SELECTVI", ":", "case", "Nyuzi", "::", "SELECTVF", ":", "case", "Nyuzi", "::", "SELECTMASK", ":", "return", "EmitSelectCC", "(", "MI", ",", "BB", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_ADDR", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ADDISSS", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_ADDI", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ADDISSI", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_SUBR", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "SUBISSS", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_NANDR", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ANDSSS", ",", "true", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_SUBI", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "SUBISSI", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_ANDR", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ANDSSS", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_ANDI", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ANDSSI", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_ORR", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ORSSS", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_ORI", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ORSSI", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_XORR", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "XORSSS", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_XORI", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "XORSSI", ")", ";", "case", "Nyuzi", "::", "ATOMIC_LOAD_NANDI", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "Nyuzi", "::", "ANDSSI", ",", "true", ")", ";", "case", "Nyuzi", "::", "ATOMIC_SWAP", ":", "return", "EmitAtomicBinary", "(", "MI", ",", "BB", ",", "0", ")", ";", "case", "Nyuzi", "::", "ATOMIC_CMP_SWAP", ":", "return", "EmitAtomicCmpSwap", "(", "MI", ",", "BB", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unknown atomic operation\"", ")", ";", "}", "}", "</s>" ]

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

[ "Nyuzi", "Nyuzi", "Nyuzi::SELECTI", "Nyuzi::SELECTF", "Nyuzi::SELECTVI", "Nyuzi::SELECTVF", "Nyuzi::SELECTMASK", "Nyuzi::ATOMIC_LOAD_ADDR", "Nyuzi::ADDISSS", "Nyuzi::ATOMIC_LOAD_ADDI", "Nyuzi::ADDISSI", "Nyuzi::ATOMIC_LOAD_SUBR", "Nyuzi::SUBISSS", "Nyuzi::ATOMIC_LOAD_NANDR", "Nyuzi::ANDSSS", "Nyuzi::ATOMIC_LOAD_SUBI", "Nyuzi::SUBISSI", "Nyuzi::ATOMIC_LOAD_ANDR", "Nyuzi::ANDSSS", "Nyuzi::ATOMIC_LOAD_ANDI", "Nyuzi::ANDSSI", "Nyuzi::ATOMIC_LOAD_ORR", "Nyuzi::ORSSS", "Nyuzi::ATOMIC_LOAD_ORI", "Nyuzi::ORSSI", "Nyuzi::ATOMIC_LOAD_XORR", "Nyuzi::XORSSS", "Nyuzi::ATOMIC_LOAD_XORI", "Nyuzi::XORSSI", "Nyuzi::ATOMIC_LOAD_NANDI", "Nyuzi::ANDSSI", "Nyuzi::ATOMIC_SWAP", "0", "Nyuzi::ATOMIC_CMP_SWAP", "\"unknown atomic operation\"" ]

[]

[ "<s>", "void", "s390_expand_vec_compare_cc", "(", "rtx", "target", ",", "enum", "rtx_code", "code", ",", "rtx", "cmp1", ",", "rtx", "cmp2", ",", "bool", "all_p", ")", "{", "enum", "rtx_code", "new_code", "=", "code", ";", "machine_mode", "cmp_mode", ",", "full_cmp_mode", ",", "scratch_mode", ";", "rtx", "tmp_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "bool", "swap_p", "=", "false", ";", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "cmp1", ")", ")", "==", "MODE_VECTOR_INT", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "cmp_mode", "=", "CCVEQmode", ";", "break", ";", "case", "NE", ":", "cmp_mode", "=", "CCVEQmode", ";", "break", ";", "case", "GT", ":", "cmp_mode", "=", "CCVHmode", ";", "break", ";", "case", "GE", ":", "cmp_mode", "=", "CCVHmode", ";", "new_code", "=", "LE", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LT", ":", "cmp_mode", "=", "CCVHmode", ";", "new_code", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cmp_mode", "=", "CCVHmode", ";", "new_code", "=", "LE", ";", "break", ";", "case", "GTU", ":", "cmp_mode", "=", "CCVHUmode", ";", "break", ";", "case", "GEU", ":", "cmp_mode", "=", "CCVHUmode", ";", "new_code", "=", "LEU", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LTU", ":", "cmp_mode", "=", "CCVHUmode", ";", "new_code", "=", "GTU", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LEU", ":", "cmp_mode", "=", "CCVHUmode", ";", "new_code", "=", "LEU", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "scratch_mode", "=", "GET_MODE", "(", "cmp1", ")", ";", "}", "else", "if", "(", "GET_MODE", "(", "cmp1", ")", "==", "V2DFmode", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "cmp_mode", "=", "CCVEQmode", ";", "break", ";", "case", "NE", ":", "cmp_mode", "=", "CCVEQmode", ";", "break", ";", "case", "GT", ":", "cmp_mode", "=", "CCVFHmode", ";", "break", ";", "case", "GE", ":", "cmp_mode", "=", "CCVFHEmode", ";", "break", ";", "case", "UNLE", ":", "cmp_mode", "=", "CCVFHmode", ";", "break", ";", "case", "UNLT", ":", "cmp_mode", "=", "CCVFHEmode", ";", "break", ";", "case", "LT", ":", "cmp_mode", "=", "CCVFHmode", ";", "new_code", "=", "GT", ";", "swap_p", "=", "true", ";", "break", ";", "case", "LE", ":", "cmp_mode", "=", "CCVFHEmode", ";", "new_code", "=", "GE", ";", "swap_p", "=", "true", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "scratch_mode", "=", "V2DImode", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "!", "all_p", ")", "switch", "(", "cmp_mode", ")", "{", "case", "CCVEQmode", ":", "full_cmp_mode", "=", "CCVEQANYmode", ";", "break", ";", "case", "CCVHmode", ":", "full_cmp_mode", "=", "CCVHANYmode", ";", "break", ";", "case", "CCVHUmode", ":", "full_cmp_mode", "=", "CCVHUANYmode", ";", "break", ";", "case", "CCVFHmode", ":", "full_cmp_mode", "=", "CCVFHANYmode", ";", "break", ";", "case", "CCVFHEmode", ":", "full_cmp_mode", "=", "CCVFHEANYmode", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "else", "full_cmp_mode", "=", "cmp_mode", ";", "if", "(", "swap_p", ")", "{", "rtx", "tmp", "=", "cmp2", ";", "cmp2", "=", "cmp1", ";", "cmp1", "=", "tmp", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "cmp_mode", ",", "CC_REGNUM", ")", ",", "gen_rtx_COMPARE", "(", "cmp_mode", ",", "cmp1", ",", "cmp2", ")", ")", ",", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_SCRATCH", "(", "scratch_mode", ")", ")", ")", ")", ")", ";", "emit_move_insn", "(", "target", ",", "const0_rtx", ")", ";", "emit_move_insn", "(", "tmp_reg", ",", "const1_rtx", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "gen_rtx_fmt_ee", "(", "new_code", ",", "VOIDmode", ",", "gen_rtx_REG", "(", "full_cmp_mode", ",", "CC_REGNUM", ")", ",", "const0_rtx", ")", ",", "target", ",", "tmp_reg", ")", ")", ";", "}", "</s>" ]

[ "Expand", "the", "comparison", "CODE", "of", "CMP1", "and", "CMP2", "and", "copy", "1", "or", "0", "into", "TARGET", "if", "either", "all", "(", "ALL_P", "is", "true", ")", "or", "any", "(", "ALL_P", "is", "false", ")", "of", "the", "elements", "in", "CMP1", "and", "CMP2", "fulfill", "the", "comparison", "." ]

[ "s390", "2" ]

[]

[ "<s>", "bool", "SHUXIFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "SHUXI", "SHUXI" ]

[]

[ "<s>", "void", "function_arg_advance", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "named", "ATTRIBUTE_UNUSED", ")", "{", "int", "bytes", "=", "avr_num_arg_regs", "(", "mode", ",", "type", ")", ";", "cum", "->", "nregs", "-=", "bytes", ";", "cum", "->", "regno", "-=", "bytes", ";", "if", "(", "cum", "->", "nregs", "<=", "0", ")", "{", "cum", "->", "nregs", "=", "0", ";", "cum", "->", "regno", "=", "FIRST_CUM_REG", ";", "}", "}", "</s>" ]

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

[ "avr", "0", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "ARM_LOW_OVERHEAD_LOOPS_NAME", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "const", "uint16_t", "*", "VideocoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_VC4_SaveList", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore", "VC" ]

[]

[ "<s>", "void", "X86DAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "OptForSize", "=", "MF", "->", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "OptimizeForSize", ")", ";", "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", "&&", "!", "Subtarget", "->", "callRegIndirect", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "TC_RETURN", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "X86ISD", "::", "CALL", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "1", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "0", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "EVT", "SrcVT", "=", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ";", "EVT", "DstVT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "if", "(", "SrcVT", ".", "isVector", "(", ")", "||", "DstVT", ".", "isVector", "(", ")", ")", "continue", ";", "bool", "SrcIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "SrcVT", ")", ";", "bool", "DstIsSSE", "=", "X86Lowering", ".", "isScalarFPTypeInSSEReg", "(", "DstVT", ")", ";", "if", "(", "SrcIsSSE", "&&", "DstIsSSE", ")", "continue", ";", "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "1", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "SDLoc", "dl", "(", "N", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "0", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "dl", ",", "DstVT", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "0", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "0", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86ISD::CALL", "X86ISD::TC_RETURN", "X86ISD::CALL", "0", "1", "0", "ISD::FP_ROUND", "ISD::FP_EXTEND", "0", "0", "X86", "X86", "ISD::FP_EXTEND", "1", "ISD::FP_ROUND", "0", "0", "ISD::EXTLOAD", "0", "0" ]

[]

[ "<s>", "static", "bool", "sh_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "1", "&&", "(", "!", "TARGET_SHCOMPACT", "||", "crtl", "->", "args", ".", "info", ".", "stack_regs", "==", "0", ")", "&&", "!", "sh_cfun_interrupt_handler_p", "(", ")", "&&", "(", "!", "flag_pic", "||", "(", "decl", "&&", "!", "TREE_PUBLIC", "(", "decl", ")", ")", "||", "(", "decl", "&&", "DECL_VISIBILITY", "(", "decl", ")", "!=", "VISIBILITY_DEFAULT", ")", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "long", "compute_frame_size", "(", "int", "size", ")", "{", "int", "regno", ";", "if", "(", "cfun", "->", "static_chain_decl", "!=", "NULL", ")", "size", "+=", "(", "1", "*", "UNITS_PER_WORD", ")", ";", "xtensa_callee_save_size", "=", "0", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "++", "regno", ")", "{", "if", "(", "xtensa_call_save_reg", "(", "regno", ")", ")", "xtensa_callee_save_size", "+=", "UNITS_PER_WORD", ";", "}", "xtensa_current_frame_size", "=", "XTENSA_STACK_ALIGN", "(", "size", "+", "xtensa_callee_save_size", "+", "crtl", "->", "outgoing_args_size", "+", "(", "WINDOW_SIZE", "*", "UNITS_PER_WORD", ")", ")", ";", "xtensa_callee_save_size", "=", "XTENSA_STACK_ALIGN", "(", "xtensa_callee_save_size", ")", ";", "return", "xtensa_current_frame_size", ";", "}", "</s>" ]

[ "Typical", "stack", "layout", "should", "looks", "like", "this", "after", "the", "function", "'s", "prologue", ":", "|", "|", "--", "^", "|", "|", "\\", "|", "|", "|", "arguments", "saved", "|", "Increasing", "|", "|", "on", "the", "stack", "|", "addresses", "PARENT", "arg", "pointer", "-", ">", "|", "|", "/", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "-", "|", "|", "-", "space", "for", "argument", "split", "between", "regs", "&", "stack", "--", "CHILD", "|", "|", "\\", "<", "--", "(", "return", "address", "here", ")", "|", "|", "other", "call", "|", "|", "saved", "registers", "|", "|", "/", "--", "frame", "pointer", "-", ">", "|", "|", "\\", "___", "|", "|", "local", "|", "|", "|", "variables", "|f", "|", "|", "/", "|r", "--", "|a", "|", "|", "\\", "|m", "|", "|", "outgoing", "|e", "|", "|", "arguments", "|", "|", "Decreasing", "(", "hard", ")", "frame", "pointer", "|", "|", "/", "|", "|", "addresses", "and", "stack", "pointer", "-", ">", "|", "|", "/", "_|_", "|", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "V" ]

[ "xtensa", "1", "0", "0" ]

[]

[ "<s>", "static", "rtx", "pop", "(", "int", "rn", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "word_mode", ",", "rn", ")", ";", "rtx", "x", ";", "if", "(", "!", "TARGET_NORMAL_MODE", ")", "x", "=", "gen_pop_h8300hs_advanced", "(", "reg", ")", ";", "else", "x", "=", "gen_pop_h8300hs_normal", "(", "reg", ")", ";", "x", "=", "emit_insn", "(", "x", ")", ";", "add_reg_note", "(", "x", ",", "REG_INC", ",", "stack_pointer_rtx", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]

[ "h8300" ]

[]

[ "<s>", "static", "bool", "ix86_noce_conversion_profitable_p", "(", "rtx_insn", "*", "seq", ",", "struct", "noce_if_info", "*", "if_info", ")", "{", "if", "(", "TARGET_ONE_IF_CONV_INSN", "&&", "if_info", "->", "speed_p", ")", "{", "int", "cmov_cnt", "=", "0", ";", "for", "(", "rtx_insn", "*", "insn", "=", "seq", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "continue", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "set", ")", ")", "!=", "IF_THEN_ELSE", ")", "continue", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_INT", "&&", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_FLOAT", ")", "continue", ";", "if", "(", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "||", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "2", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "2", ")", ")", ")", ")", "continue", ";", "if", "(", "++", "cmov_cnt", ">", "1", ")", "return", "false", ";", "}", "}", "return", "default_noce_conversion_profitable_p", "(", "seq", ",", "if_info", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SEQ", "is", "a", "good", "candidate", "as", "a", "replacement", "for", "the", "if-convertible", "sequence", "described", "in", "IF_INFO", "." ]

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

[]

[ "<s>", "LoadInst", "*", "X86TargetLowering", "::", "lowerIdempotentRMWIntoFencedLoad", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "getTargetMachine", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "unsigned", "NativeWidth", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "const", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "nullptr", ";", "auto", "Builder", "=", "IRBuilder", "<", ">", "(", "AI", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "SynchScope", "=", "AI", "->", "getSynchScope", "(", ")", ";", "auto", "Order", "=", "AtomicCmpXchgInst", "::", "getStrongestFailureOrdering", "(", "AI", "->", "getOrdering", "(", ")", ")", ";", "auto", "Ptr", "=", "AI", "->", "getPointerOperand", "(", ")", ";", "if", "(", "SynchScope", "==", "SingleThread", ")", "{", "return", "nullptr", ";", "}", "else", "if", "(", "hasMFENCE", "(", "Subtarget", ")", ")", "{", "Function", "*", "MFence", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "x86_sse2_mfence", ")", ";", "Builder", ".", "CreateCall", "(", "MFence", ")", ";", "}", "else", "{", "return", "nullptr", ";", "}", "LoadInst", "*", "Loaded", "=", "Builder", ".", "CreateAlignedLoad", "(", "Ptr", ",", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ")", ";", "Loaded", "->", "setAtomic", "(", "Order", ",", "SynchScope", ")", ";", "AI", "->", "replaceAllUsesWith", "(", "Loaded", ")", ";", "AI", "->", "eraseFromParent", "(", ")", ";", "return", "Loaded", ";", "}", "</s>" ]

[ "On", "some", "platforms", ",", "an", "AtomicRMW", "that", "never", "actually", "modifies", "the", "value", "(", "such", "as", "fetch_add", "of", "0", ")", "can", "be", "turned", "into", "a", "fence", "followed", "by", "an", "atomic", "load", "." ]

[ "X86", "X86", "X86", "X86", "64", "32", "Intrinsic::getDeclaration", "Intrinsic::x86_sse2_mfence" ]

[]

[ "<s>", "static", "void", "rs6000_invalid_builtin", "(", "enum", "rs6000_builtins", "fncode", ")", "{", "size_t", "uns_fncode", "=", "(", "size_t", ")", "fncode", ";", "const", "char", "*", "name", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "name", ";", "HOST_WIDE_INT", "fnmask", "=", "rs6000_builtin_info", "[", "uns_fncode", "]", ".", "mask", ";", "gcc_assert", "(", "name", "!=", "NULL", ")", ";", "if", "(", "(", "fnmask", "&", "RS6000_BTM_CELL", ")", "!=", "0", ")", "error", "(", "\"%qs is only valid for the cell processor\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_VSX", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mvsx\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HTM", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mhtm\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_ALTIVEC", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-maltivec\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "==", "(", "RS6000_BTM_DFP", "|", "RS6000_BTM_P8_VECTOR", ")", ")", "error", "(", "\"%qs requires the %qs and %qs options\"", ",", "name", ",", "\"-mhard-dfp\"", ",", "\"-mpower8-vector\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_DFP", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mhard-dfp\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P8_VECTOR", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mpower8-vector\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_P9_VECTOR", "|", "RS6000_BTM_64BIT", ")", ")", "==", "(", "RS6000_BTM_P9_VECTOR", "|", "RS6000_BTM_64BIT", ")", ")", "error", "(", "\"%qs requires the %qs and %qs options\"", ",", "name", ",", "\"-mcpu=power9\"", ",", "\"-m64\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P9_VECTOR", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mcpu=power9\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_P9_MISC", "|", "RS6000_BTM_64BIT", ")", ")", "==", "(", "RS6000_BTM_P9_MISC", "|", "RS6000_BTM_64BIT", ")", ")", "error", "(", "\"%qs requires the %qs and %qs options\"", ",", "name", ",", "\"-mcpu=power9\"", ",", "\"-m64\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_P9_MISC", ")", "==", "RS6000_BTM_P9_MISC", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mcpu=power9\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_LDBL128", ")", "==", "RS6000_BTM_LDBL128", ")", "{", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mhard-float\"", ")", ";", "else", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "TARGET_IEEEQUAD", "?", "\"-mabi=ibmlongdouble\"", ":", "\"-mlong-double-128\"", ")", ";", "}", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_HARD_FLOAT", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"-mhard-float\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_FLOAT128_HW", ")", "!=", "0", ")", "error", "(", "\"%qs requires ISA 3.0 IEEE 128-bit floating point\"", ",", "name", ")", ";", "else", "if", "(", "(", "fnmask", "&", "RS6000_BTM_FLOAT128", ")", "!=", "0", ")", "error", "(", "\"%qs requires the %qs option\"", ",", "name", ",", "\"%<-mfloat128%>\"", ")", ";", "else", "if", "(", "(", "fnmask", "&", "(", "RS6000_BTM_POPCNTD", "|", "RS6000_BTM_POWERPC64", ")", ")", "==", "(", "RS6000_BTM_POPCNTD", "|", "RS6000_BTM_POWERPC64", ")", ")", "error", "(", "\"%qs requires the %qs (or newer), and %qs or %qs options\"", ",", "name", ",", "\"-mcpu=power7\"", ",", "\"-m64\"", ",", "\"-mpowerpc64\"", ")", ";", "else", "error", "(", "\"%qs is not supported with the current options\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Raise", "an", "error", "message", "for", "a", "builtin", "function", "that", "is", "called", "without", "the", "appropriate", "target", "options", "being", "set", "." ]

[ "rs6000", "0", "\"%qs is only valid for the cell processor\"", "0", "\"%qs requires the %qs option\"", "\"-mvsx\"", "0", "\"%qs requires the %qs option\"", "\"-mhtm\"", "0", "\"%qs requires the %qs option\"", "\"-maltivec\"", "\"%qs requires the %qs and %qs options\"", "\"-mhard-dfp\"", "\"-mpower8-vector\"", "0", "\"%qs requires the %qs option\"", "\"-mhard-dfp\"", "0", "\"%qs requires the %qs option\"", "\"-mpower8-vector\"", "\"%qs requires the %qs and %qs options\"", "\"-mcpu=power9\"", "\"-m64\"", "0", "\"%qs requires the %qs option\"", "\"-mcpu=power9\"", "\"%qs requires the %qs and %qs options\"", "\"-mcpu=power9\"", "\"-m64\"", "\"%qs requires the %qs option\"", "\"-mcpu=power9\"", "\"%qs requires the %qs option\"", "\"-mhard-float\"", "\"%qs requires the %qs option\"", "\"-mabi=ibmlongdouble\"", "\"-mlong-double-128\"", "0", "\"%qs requires the %qs option\"", "\"-mhard-float\"", "0", "\"%qs requires ISA 3.0 IEEE 128-bit floating point\"", "0", "\"%qs requires the %qs option\"", "\"%<-mfloat128%>\"", "\"%qs requires the %qs (or newer), and %qs or %qs options\"", "\"-mcpu=power7\"", "\"-m64\"", "\"-mpowerpc64\"", "\"%qs is not supported with the current options\"" ]

[]

[ "<s>", "bool", "Mips16RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "DebugLoc", "DL", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TII", ".", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "Mips", "::", "T0", ",", "Reg", ",", "true", ")", ";", "TII", ".", "copyPhysReg", "(", "MBB", ",", "UseMI", ",", "DL", ",", "Reg", ",", "Mips", "::", "T0", ",", "true", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "Mips", "Mips", "Mips::T0", "Mips::T0" ]

[]

[ "<s>", "static", "void", "ix86_function_specific_restore", "(", "struct", "gcc_options", "*", "opts", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "enum", "processor_type", "old_tune", "=", "ix86_tune", ";", "enum", "processor_type", "old_arch", "=", "ix86_arch", ";", "unsigned", "HOST_WIDE_INT", "ix86_arch_mask", ";", "int", "i", ";", "opts", "->", "x_flag_pic", "=", "flag_pic", ";", "ix86_arch", "=", "(", "enum", "processor_type", ")", "ptr", "->", "arch", ";", "ix86_schedule", "=", "(", "enum", "attr_cpu", ")", "ptr", "->", "schedule", ";", "ix86_tune", "=", "(", "enum", "processor_type", ")", "ptr", "->", "tune", ";", "x86_prefetch_sse", "=", "ptr", "->", "prefetch_sse", ";", "opts", "->", "x_ix86_branch_cost", "=", "ptr", "->", "branch_cost", ";", "ix86_tune_defaulted", "=", "ptr", "->", "tune_defaulted", ";", "ix86_arch_specified", "=", "ptr", "->", "arch_specified", ";", "opts", "->", "x_ix86_isa_flags_explicit", "=", "ptr", "->", "x_ix86_isa_flags_explicit", ";", "opts", "->", "x_ix86_isa_flags2_explicit", "=", "ptr", "->", "x_ix86_isa_flags2_explicit", ";", "opts", "->", "x_recip_mask_explicit", "=", "ptr", "->", "x_recip_mask_explicit", ";", "opts", "->", "x_ix86_arch_string", "=", "ptr", "->", "x_ix86_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "ptr", "->", "x_ix86_tune_string", ";", "opts", "->", "x_ix86_cmodel", "=", "ptr", "->", "x_ix86_cmodel", ";", "opts", "->", "x_ix86_abi", "=", "ptr", "->", "x_ix86_abi", ";", "opts", "->", "x_ix86_asm_dialect", "=", "ptr", "->", "x_ix86_asm_dialect", ";", "opts", "->", "x_ix86_branch_cost", "=", "ptr", "->", "x_ix86_branch_cost", ";", "opts", "->", "x_ix86_dump_tunes", "=", "ptr", "->", "x_ix86_dump_tunes", ";", "opts", "->", "x_ix86_force_align_arg_pointer", "=", "ptr", "->", "x_ix86_force_align_arg_pointer", ";", "opts", "->", "x_ix86_force_drap", "=", "ptr", "->", "x_ix86_force_drap", ";", "opts", "->", "x_ix86_incoming_stack_boundary_arg", "=", "ptr", "->", "x_ix86_incoming_stack_boundary_arg", ";", "opts", "->", "x_ix86_pmode", "=", "ptr", "->", "x_ix86_pmode", ";", "opts", "->", "x_ix86_preferred_stack_boundary_arg", "=", "ptr", "->", "x_ix86_preferred_stack_boundary_arg", ";", "opts", "->", "x_ix86_recip_name", "=", "ptr", "->", "x_ix86_recip_name", ";", "opts", "->", "x_ix86_regparm", "=", "ptr", "->", "x_ix86_regparm", ";", "opts", "->", "x_ix86_section_threshold", "=", "ptr", "->", "x_ix86_section_threshold", ";", "opts", "->", "x_ix86_sse2avx", "=", "ptr", "->", "x_ix86_sse2avx", ";", "opts", "->", "x_ix86_stack_protector_guard", "=", "ptr", "->", "x_ix86_stack_protector_guard", ";", "opts", "->", "x_ix86_stringop_alg", "=", "ptr", "->", "x_ix86_stringop_alg", ";", "opts", "->", "x_ix86_tls_dialect", "=", "ptr", "->", "x_ix86_tls_dialect", ";", "opts", "->", "x_ix86_tune_ctrl_string", "=", "ptr", "->", "x_ix86_tune_ctrl_string", ";", "opts", "->", "x_ix86_tune_memcpy_strategy", "=", "ptr", "->", "x_ix86_tune_memcpy_strategy", ";", "opts", "->", "x_ix86_tune_memset_strategy", "=", "ptr", "->", "x_ix86_tune_memset_strategy", ";", "opts", "->", "x_ix86_tune_no_default", "=", "ptr", "->", "x_ix86_tune_no_default", ";", "opts", "->", "x_ix86_veclibabi_type", "=", "ptr", "->", "x_ix86_veclibabi_type", ";", "ix86_tune_cost", "=", "processor_target_table", "[", "ix86_tune", "]", ".", "cost", ";", "if", "(", "opts", "->", "x_optimize_size", ")", "ix86_cost", "=", "&", "ix86_size_cost", ";", "else", "ix86_cost", "=", "ix86_tune_cost", ";", "if", "(", "old_arch", "!=", "ix86_arch", ")", "{", "ix86_arch_mask", "=", "HOST_WIDE_INT_1U", "<<", "ix86_arch", ";", "for", "(", "i", "=", "0", ";", "i", "<", "X86_ARCH_LAST", ";", "++", "i", ")", "ix86_arch_features", "[", "i", "]", "=", "!", "!", "(", "initial_ix86_arch_features", "[", "i", "]", "&", "ix86_arch_mask", ")", ";", "}", "if", "(", "old_tune", "!=", "ix86_tune", ")", "set_ix86_tune_features", "(", "ix86_tune", ",", "false", ")", ";", "}", "</s>" ]

[ "Restore", "the", "current", "options" ]

[ "i386", "0" ]

[]

[ "<s>", "MachineOperand", "*", "SIInstrInfo", "::", "getNamedOperand", "(", "MachineInstr", "&", "MI", ",", "unsigned", "OperandName", ")", "const", "{", "int", "Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", ".", "getOpcode", "(", ")", ",", "OperandName", ")", ";", "if", "(", "Idx", "==", "-", "1", ")", "return", "nullptr", ";", "return", "&", "MI", ".", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "operand", "named", "Op", "." ]

[ "R600", "SI", "1" ]

[]

[ "<s>", "AArch64Subtarget", "::", "AArch64Subtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ",", "bool", "LittleEndian", ",", "unsigned", "MinSVEVectorSizeInBitsOverride", ",", "unsigned", "MaxSVEVectorSizeInBitsOverride", ")", ":", "AArch64GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "ReserveXRegister", "(", "AArch64", "::", "GPR64commonRegClass", ".", "getNumRegs", "(", ")", ")", ",", "CustomCallSavedXRegs", "(", "AArch64", "::", "GPR64commonRegClass", ".", "getNumRegs", "(", ")", ")", ",", "IsLittle", "(", "LittleEndian", ")", ",", "MinSVEVectorSizeInBits", "(", "MinSVEVectorSizeInBitsOverride", ")", ",", "MaxSVEVectorSizeInBits", "(", "MaxSVEVectorSizeInBitsOverride", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ",", "CPU", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "if", "(", "AArch64", "::", "isX18ReservedByDefault", "(", "TT", ")", ")", "ReserveXRegister", ".", "set", "(", "18", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "InlineAsmLoweringInfo", ".", "reset", "(", "new", "InlineAsmLowering", "(", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "AArch64LegalizerInfo", "(", "*", "this", ")", ")", ";", "auto", "*", "RBI", "=", "new", "AArch64RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "InstSelector", ".", "reset", "(", "createAArch64InstructionSelector", "(", "*", "static_cast", "<", "const", "AArch64TargetMachine", "*", ">", "(", "&", "TM", ")", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::GPR64commonRegClass", "AArch64::GPR64commonRegClass", "AArch64::isX18ReservedByDefault", "18", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "resize", "(", "HRI", ".", "getNumRegs", "(", ")", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ")", "for", "(", "const", "MCPhysReg", "*", "R", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "SavedRegs", ".", "set", "(", "*", "R", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "NewRegs", ";", "expandSpillMacros", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "OptimizeSpillSlots", "&&", "!", "isOptNone", "(", "MF", ")", ")", "optimizeSpillSlots", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "!", "NewRegs", ".", "empty", "(", ")", "||", "mayOverflowFrameOffset", "(", "MF", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SetVector", "<", "const", "TargetRegisterClass", "*", ">", "SpillRCs", ";", "SpillRCs", ".", "insert", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "for", "(", "unsigned", "VR", ":", "NewRegs", ")", "SpillRCs", ".", "insert", "(", "MRI", ".", "getRegClass", "(", "VR", ")", ")", ";", "for", "(", "auto", "*", "RC", ":", "SpillRCs", ")", "{", "if", "(", "!", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ",", "RC", ")", ")", "continue", ";", "unsigned", "Num", "=", "1", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "case", "Hexagon", "::", "IntRegsRegClassID", ":", "Num", "=", "NumberScavengerSlots", ";", "break", ";", "case", "Hexagon", "::", "HvxQRRegClassID", ":", "Num", "=", "2", ";", "break", ";", "}", "unsigned", "S", "=", "HRI", ".", "getSpillSize", "(", "*", "RC", ")", ";", "Align", "A", "=", "HRI", ".", "getSpillAlign", "(", "*", "RC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Num", ";", "i", "++", ")", "{", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "S", ",", "A", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "}", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon::IntRegsRegClass", "1", "Hexagon::IntRegsRegClassID", "Hexagon::HvxQRRegClassID", "2", "0" ]

[]

[ "<s>", "static", "bool", "riscv_check_builtin_call", "(", "location_t", "loc", ",", "vec", "<", "location_t", ">", "arg_loc", ",", "tree", "fndecl", ",", "tree", "orig_fndecl", ",", "unsigned", "int", "nargs", ",", "tree", "*", "args", ")", "{", "unsigned", "int", "code", "=", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ";", "unsigned", "int", "subcode", "=", "code", ">>", "RISCV_BUILTIN_SHIFT", ";", "switch", "(", "code", "&", "RISCV_BUILTIN_CLASS", ")", "{", "case", "RISCV_BUILTIN_GENERAL", ":", "return", "true", ";", "case", "RISCV_BUILTIN_VECTOR", ":", "return", "riscv_vector", "::", "check_builtin_call", "(", "loc", ",", "arg_loc", ",", "subcode", ",", "orig_fndecl", ",", "nargs", ",", "args", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CHECK_BUILTIN_CALL", "." ]

[ "riscv", "riscv_vector::check_builtin_call" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Patmos Bypass From PML\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Bypass From PML\"" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "printInstruction", "(", "MI", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

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

[ "Blackfin" ]

[]

[ "<s>", "void", "SPIRVPassConfig", "::", "addPreGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "createSPIRVGenerateDecorationsPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "the", "(", "global", ")", "instruction", "selection", "." ]

[ "SPIRV", "SPIRV", "SPIRV" ]

[]

[ "<s>", "rtx", "aarch64_simd_expand_builtin", "(", "int", "fcode", ",", "tree", "exp", ",", "rtx", "target", ")", "{", "if", "(", "fcode", "==", "AARCH64_SIMD_BUILTIN_LANE_CHECK", ")", "{", "rtx", "totalsize", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "rtx", "elementsize", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "totalsize", ")", "&&", "CONST_INT_P", "(", "elementsize", ")", "&&", "UINTVAL", "(", "elementsize", ")", "!=", "0", "&&", "UINTVAL", "(", "totalsize", ")", "!=", "0", ")", "{", "rtx", "lane_idx", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ";", "if", "(", "CONST_INT_P", "(", "lane_idx", ")", ")", "aarch64_simd_lane_bounds", "(", "lane_idx", ",", "0", ",", "UINTVAL", "(", "totalsize", ")", "/", "UINTVAL", "(", "elementsize", ")", ",", "exp", ")", ";", "else", "error", "(", "\"%Klane index must be a constant immediate\"", ",", "exp", ")", ";", "}", "else", "error", "(", "\"%Ktotal size and element size must be a non-zero constant immediate\"", ",", "exp", ")", ";", "return", "const0_rtx", ";", "}", "aarch64_simd_builtin_datum", "*", "d", "=", "&", "aarch64_simd_builtin_data", "[", "fcode", "-", "AARCH64_SIMD_PATTERN_START", "]", ";", "enum", "insn_code", "icode", "=", "d", "->", "code", ";", "builtin_simd_arg", "args", "[", "SIMD_MAX_BUILTIN_ARGS", "+", "1", "]", ";", "int", "num_args", "=", "insn_data", "[", "d", "->", "code", "]", ".", "n_operands", ";", "int", "is_void", "=", "0", ";", "int", "k", ";", "is_void", "=", "!", "!", "(", "d", "->", "qualifiers", "[", "0", "]", "&", "qualifier_void", ")", ";", "num_args", "+=", "is_void", ";", "for", "(", "k", "=", "1", ";", "k", "<", "num_args", ";", "k", "++", ")", "{", "int", "qualifiers_k", "=", "k", ";", "int", "operands_k", "=", "k", "-", "is_void", ";", "int", "expr_args_k", "=", "k", "-", "1", ";", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_lane_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_struct_load_store_lane_index", ")", "args", "[", "k", "]", "=", "SIMD_ARG_STRUCT_LOAD_STORE_LANE_INDEX", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_immediate", ")", "args", "[", "k", "]", "=", "SIMD_ARG_CONSTANT", ";", "else", "if", "(", "d", "->", "qualifiers", "[", "qualifiers_k", "]", "&", "qualifier_maybe_immediate", ")", "{", "rtx", "arg", "=", "expand_normal", "(", "CALL_EXPR_ARG", "(", "exp", ",", "(", "expr_args_k", ")", ")", ")", ";", "bool", "op_const_int_p", "=", "(", "CONST_INT_P", "(", "arg", ")", "&&", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "predicate", ")", "(", "arg", ",", "insn_data", "[", "icode", "]", ".", "operand", "[", "operands_k", "]", ".", "mode", ")", ")", ";", "args", "[", "k", "]", "=", "op_const_int_p", "?", "SIMD_ARG_CONSTANT", ":", "SIMD_ARG_COPY_TO_REG", ";", "}", "else", "args", "[", "k", "]", "=", "SIMD_ARG_COPY_TO_REG", ";", "}", "args", "[", "k", "]", "=", "SIMD_ARG_STOP", ";", "return", "aarch64_simd_expand_args", "(", "target", ",", "icode", ",", "!", "is_void", ",", "exp", ",", "&", "args", "[", "1", "]", ",", "d", "->", "mode", ")", ";", "}", "</s>" ]

[ "Expand", "an", "AArch64", "AdvSIMD", "builtin", "(", "intrinsic", ")", "." ]

[ "aarch64", "0", "1", "0", "0", "2", "0", "\"%Klane index must be a constant immediate\"", "\"%Ktotal size and element size must be a non-zero constant immediate\"", "1", "0", "0", "1", "1", "1" ]

[]

[ "<s>", "MCFixupKindInfo", "const", "&", "SNESAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "SNES", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_7_pcrel\"", ",", "3", ",", "7", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_13_pcrel\"", ",", "0", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_16_pm\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_call\"", ",", "0", ",", "22", ",", "0", "}", ",", "{", "\"fixup_6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_6_adiw\"", ",", "0", ",", "6", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_lo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hi8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hlo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_sym_diff\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_16_ldst\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_lds_sts_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port5\"", ",", "3", ",", "5", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "SNES", "SNES", "SNES::NumTargetFixupKinds", "\"fixup_32\"", "0", "32", "0", "\"fixup_7_pcrel\"", "3", "7", "\"fixup_13_pcrel\"", "0", "12", "\"fixup_16\"", "0", "16", "0", "\"fixup_16_pm\"", "0", "16", "0", "\"fixup_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi\"", "0", "8", "0", "\"fixup_hi8_ldi\"", "0", "8", "0", "\"fixup_hh8_ldi\"", "0", "8", "0", "\"fixup_ms8_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_neg\"", "0", "8", "0", "\"fixup_ms8_ldi_neg\"", "0", "8", "0", "\"fixup_lo8_ldi_pm\"", "0", "8", "0", "\"fixup_hi8_ldi_pm\"", "0", "8", "0", "\"fixup_hh8_ldi_pm\"", "0", "8", "0", "\"fixup_lo8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_call\"", "0", "22", "0", "\"fixup_6\"", "0", "16", "0", "\"fixup_6_adiw\"", "0", "6", "0", "\"fixup_lo8_ldi_gs\"", "0", "8", "0", "\"fixup_hi8_ldi_gs\"", "0", "8", "0", "\"fixup_8\"", "0", "8", "0", "\"fixup_8_lo8\"", "0", "8", "0", "\"fixup_8_hi8\"", "0", "8", "0", "\"fixup_8_hlo8\"", "0", "8", "0", "\"fixup_sym_diff\"", "0", "32", "0", "\"fixup_16_ldst\"", "0", "16", "0", "\"fixup_lds_sts_16\"", "0", "16", "0", "\"fixup_port6\"", "0", "16", "0", "\"fixup_port5\"", "3", "5", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "bool", "loongarch_hard_regno_mode_ok_uncached", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "unsigned", "int", "size", ";", "enum", "mode_class", "mclass", ";", "if", "(", "mode", "==", "FCCmode", ")", "return", "FCC_REG_P", "(", "regno", ")", ";", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "mclass", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "GP_REG_P", "(", "regno", ")", ")", "return", "(", "(", "regno", "-", "GP_REG_FIRST", ")", "&", "1", ")", "==", "0", "||", "size", "<=", "UNITS_PER_WORD", ";", "if", "(", "FP_REG_P", "(", "regno", ")", ")", "{", "if", "(", "mclass", "==", "MODE_FLOAT", "||", "mclass", "==", "MODE_COMPLEX_FLOAT", "||", "mclass", "==", "MODE_VECTOR_FLOAT", ")", "return", "size", "<=", "UNITS_PER_FPVALUE", ";", "if", "(", "mclass", "==", "MODE_INT", ")", "return", "size", ">=", "MIN_UNITS_PER_WORD", "&&", "size", "<=", "UNITS_PER_FPREG", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "register", "REGNO", "can", "store", "a", "value", "of", "mode", "MODE", ".", "The", "result", "of", "this", "function", "is", "cached", "in", "loongarch_hard_regno_mode_ok", "." ]

[ "loongarch", "1", "0" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "return", "Subtarget", "->", "hasFP32Denormals", "(", ")", "&&", "Subtarget", "->", "hasFastFMAF32", "(", ")", ";", "case", "MVT", "::", "f64", ":", "return", "true", ";", "case", "MVT", "::", "f16", ":", "return", "Subtarget", "->", "has16BitInsts", "(", ")", "&&", "Subtarget", "->", "hasFP16Denormals", "(", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

[ "AMDGPU", "SI", "MVT::f32", "MVT::f64", "MVT::f16" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "isReallyTriviallyReMaterializable", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown rematerializable operation!\"", ")", ";", "break", ";", "case", "PPC", "::", "LI", ":", "case", "PPC", "::", "LI8", ":", "case", "PPC", "::", "PLI", ":", "case", "PPC", "::", "PLI8", ":", "case", "PPC", "::", "LIS", ":", "case", "PPC", "::", "LIS8", ":", "case", "PPC", "::", "ADDIStocHA", ":", "case", "PPC", "::", "ADDIStocHA8", ":", "case", "PPC", "::", "ADDItocL", ":", "case", "PPC", "::", "LOAD_STACK_GUARD", ":", "case", "PPC", "::", "XXLXORz", ":", "case", "PPC", "::", "XXLXORspz", ":", "case", "PPC", "::", "XXLXORdpz", ":", "case", "PPC", "::", "XXLEQVOnes", ":", "case", "PPC", "::", "XXSPLTI32DX", ":", "case", "PPC", "::", "V_SET0B", ":", "case", "PPC", "::", "V_SET0H", ":", "case", "PPC", "::", "V_SET0", ":", "case", "PPC", "::", "V_SETALLONESB", ":", "case", "PPC", "::", "V_SETALLONESH", ":", "case", "PPC", "::", "V_SETALLONES", ":", "case", "PPC", "::", "CRSET", ":", "case", "PPC", "::", "CRUNSET", ":", "case", "PPC", "::", "XXSETACCZ", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "For", "instructions", "with", "opcodes", "for", "which", "the", "M_REMATERIALIZABLE", "flag", "is", "set", ",", "this", "hook", "lets", "the", "target", "specify", "whether", "the", "instruction", "is", "actually", "trivially", "rematerializable", ",", "taking", "into", "consideration", "its", "operands", "." ]

[ "PowerPC", "PPC", "\"Unknown rematerializable operation!\"", "PPC::LI", "PPC::LI8", "PPC::PLI", "PPC::PLI8", "PPC::LIS", "PPC::LIS8", "PPC::ADDIStocHA", "PPC::ADDIStocHA8", "PPC::ADDItocL", "PPC::LOAD_STACK_GUARD", "PPC::XXLXORz", "PPC::XXLXORspz", "PPC::XXLXORdpz", "PPC::XXLEQVOnes", "PPC::XXSPLTI32DX", "PPC::V_SET0B", "PPC::V_SET0H", "PPC::V_SET0", "PPC::V_SETALLONESB", "PPC::V_SETALLONESH", "PPC::V_SETALLONES", "PPC::CRSET", "PPC::CRUNSET", "PPC::XXSETACCZ" ]

[]

[ "<s>", "bool", "ARM64InstrInfo", "::", "isLdStPairSuppressed", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "assert", "(", "MOSuppressPair", "<", "(", "1", "<<", "MachineMemOperand", "::", "MOTargetNumBits", ")", "&&", "\"Too many target MO flags\"", ")", ";", "for", "(", "auto", "*", "MM", ":", "MI", "->", "memoperands", "(", ")", ")", "{", "if", "(", "MM", "->", "getFlags", "(", ")", "&", "(", "MOSuppressPair", "<<", "MachineMemOperand", "::", "MOTargetStartBit", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "is", "hinted", "to", "be", "unprofitable", "." ]

[ "ARM64", "ARM64", "1", "\"Too many target MO flags\"" ]

[]

[ "<s>", "bool", "moxie_offset_address_p", "(", "rtx", "x", ")", "{", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "x", "=", "XEXP", "(", "x", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "{", "unsigned", "int", "v", "=", "INTVAL", "(", "x", ")", "&", "0xFFFF8000", ";", "return", "(", "v", "==", "0xFFFF8000", "||", "v", "==", "0x00000000", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "true", "for", "memory", "offset", "addresses", "between", "-32768", "and", "32767", "." ]

[ "moxie", "0", "1", "0xFFFF8000", "0xFFFF8000", "0x00000000", "0" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "{", "return", "Kind", "==", "K_Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "Nyuzi" ]

[]

[ "<s>", "const", "CallLowering", "*", "ARMSubtarget", "::", "getCallLowering", "(", ")", "const", "{", "assert", "(", "GISel", "&&", "\"Access to GlobalISel APIs not set\"", ")", ";", "return", "GISel", "->", "getCallLowering", "(", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"Access to GlobalISel APIs not set\"" ]

[]

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

[ "Returns", "true", "if", "lanemasks", "should", "be", "tracked", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "frv_expand_prologue", "(", "void", ")", "{", "frv_stack_t", "*", "info", "=", "frv_stack_info", "(", ")", ";", "rtx", "sp", "=", "stack_pointer_rtx", ";", "rtx", "fp", "=", "frame_pointer_rtx", ";", "frv_frame_accessor_t", "accessor", ";", "if", "(", "TARGET_DEBUG_STACK", ")", "frv_debug_stack", "(", "info", ")", ";", "if", "(", "info", "->", "total_size", "==", "0", ")", "return", ";", "accessor", ".", "op", "=", "FRV_STORE", ";", "if", "(", "frame_pointer_needed", "&&", "info", "->", "total_size", ">", "2048", ")", "{", "rtx", "insn", ";", "accessor", ".", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "OLD_SP_REGNO", ")", ";", "accessor", ".", "base_offset", "=", "info", "->", "total_size", ";", "insn", "=", "emit_insn", "(", "gen_movsi", "(", "accessor", ".", "base", ",", "sp", ")", ")", ";", "}", "else", "{", "accessor", ".", "base", "=", "stack_pointer_rtx", ";", "accessor", ".", "base_offset", "=", "0", ";", "}", "{", "rtx", "asm_offset", "=", "frv_frame_offset_rtx", "(", "-", "info", "->", "total_size", ")", ";", "rtx", "dwarf_offset", "=", "GEN_INT", "(", "-", "info", "->", "total_size", ")", ";", "frv_frame_insn", "(", "gen_stack_adjust", "(", "sp", ",", "sp", ",", "asm_offset", ")", ",", "gen_rtx_SET", "(", "Pmode", ",", "sp", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "sp", ",", "dwarf_offset", ")", ")", ")", ";", "}", "if", "(", "frame_pointer_needed", ")", "{", "int", "fp_offset", "=", "info", "->", "reg_offset", "[", "FRAME_POINTER_REGNUM", "]", ";", "rtx", "asm_src", "=", "plus_constant", "(", "accessor", ".", "base", ",", "fp_offset", "-", "accessor", ".", "base_offset", ")", ";", "rtx", "dwarf_src", "=", "plus_constant", "(", "sp", ",", "fp_offset", ")", ";", "frv_frame_access", "(", "&", "accessor", ",", "fp", ",", "fp_offset", ")", ";", "frv_frame_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "fp", ",", "asm_src", ")", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "fp", ",", "dwarf_src", ")", ")", ";", "accessor", ".", "base", "=", "fp", ";", "accessor", ".", "base_offset", "=", "fp_offset", ";", "}", "frv_frame_access_multi", "(", "&", "accessor", ",", "info", ",", "STACK_REGS_STRUCT", ")", ";", "frv_frame_access_multi", "(", "&", "accessor", ",", "info", ",", "STACK_REGS_LR", ")", ";", "frv_frame_access_multi", "(", "&", "accessor", ",", "info", ",", "STACK_REGS_STDARG", ")", ";", "frv_frame_access_standard_regs", "(", "FRV_STORE", ",", "info", ")", ";", "if", "(", "info", "->", "stdarg_size", ">", "0", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "if", "(", "!", "TARGET_FDPIC", "&&", "flag_pic", "&&", "cfun", "->", "uses_pic_offset_table", ")", "emit_insn", "(", "gen_pic_prologue", "(", "gen_rtx_REG", "(", "Pmode", ",", "PIC_REGNO", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "LR_REGNO", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "OFFSET_REGNO", ")", ")", ")", ";", "}", "</s>" ]

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

[ "frv", "0", "2048", "0", "0" ]

[]

[ "<s>", "BufferType", "::", "const_iterator", "begin", "(", ")", "const", "{", "return", "Buffer", ".", "begin", "(", ")", ";", "}", "</s>" ]

[ "Recipe", "iterator", "methods", "." ]

[ "M68k" ]

[]

[ "<s>", "static", "bool", "isPairableLdStInst", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "STRSui", ":", "case", "AArch64", "::", "STRDui", ":", "case", "AArch64", "::", "STRQui", ":", "case", "AArch64", "::", "STRXui", ":", "case", "AArch64", "::", "STRWui", ":", "case", "AArch64", "::", "LDRSui", ":", "case", "AArch64", "::", "LDRDui", ":", "case", "AArch64", "::", "LDRQui", ":", "case", "AArch64", "::", "LDRXui", ":", "case", "AArch64", "::", "LDRWui", ":", "case", "AArch64", "::", "LDRSWui", ":", "case", "AArch64", "::", "STURSi", ":", "case", "AArch64", "::", "STURDi", ":", "case", "AArch64", "::", "STURQi", ":", "case", "AArch64", "::", "STURWi", ":", "case", "AArch64", "::", "STURXi", ":", "case", "AArch64", "::", "LDURSi", ":", "case", "AArch64", "::", "LDURDi", ":", "case", "AArch64", "::", "LDURQi", ":", "case", "AArch64", "::", "LDURWi", ":", "case", "AArch64", "::", "LDURXi", ":", "case", "AArch64", "::", "LDURSWi", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "pairing", "the", "given", "load", "or", "store", "may", "be", "paired", "with", "another", "." ]

[ "AArch64", "AArch64::STRSui", "AArch64::STRDui", "AArch64::STRQui", "AArch64::STRXui", "AArch64::STRWui", "AArch64::LDRSui", "AArch64::LDRDui", "AArch64::LDRQui", "AArch64::LDRXui", "AArch64::LDRWui", "AArch64::LDRSWui", "AArch64::STURSi", "AArch64::STURDi", "AArch64::STURQi", "AArch64::STURWi", "AArch64::STURXi", "AArch64::LDURSi", "AArch64::LDURDi", "AArch64::LDURQi", "AArch64::LDURWi", "AArch64::LDURXi", "AArch64::LDURSWi" ]

[]

[ "<s>", "static", "bool", "aarch64_evpc_trn", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "vmode", "=", "d", "->", "vmode", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "vmode", ")", ">", "8", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "odd", "=", "0", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "1", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "2", ")", "{", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "i", "+", "odd", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "1", "]", "!=", "(", "(", "i", "+", "nelt", "+", "odd", ")", "&", "mask", ")", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "odd", "=", "!", "odd", ";", "}", "out", "=", "d", "->", "target", ";", "if", "(", "odd", ")", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_trn2v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_trn2v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_trn2v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_trn2v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_trn2v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_trn2v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_trn2v2di", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_trn2v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_trn2v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_trn2v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "else", "{", "switch", "(", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_aarch64_trn1v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_trn1v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_aarch64_trn1v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_trn1v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_aarch64_trn1v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_trn1v2si", ";", "break", ";", "case", "V2DImode", ":", "gen", "=", "gen_aarch64_trn1v2di", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_aarch64_trn1v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_trn1v2sf", ";", "break", ";", "case", "V2DFmode", ":", "gen", "=", "gen_aarch64_trn1v2df", ";", "break", ";", "default", ":", "return", "false", ";", "}", "}", "emit_insn", "(", "gen", "(", "out", ",", "in0", ",", "in1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "suitable", "for", "the", "TRN", "instructions", "." ]

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

[]

[ "<s>", "char", "*", "aarch64_output_sve_inc_dec_immediate", "(", "const", "char", "*", "operands", ",", "rtx", "x", ")", "{", "int", "factor", ";", "unsigned", "int", "nelts_per_vq", ";", "if", "(", "!", "aarch64_sve_inc_dec_immediate_p", "(", "x", ",", "&", "factor", ",", "&", "nelts_per_vq", ")", ")", "gcc_unreachable", "(", ")", ";", "if", "(", "factor", "<", "0", ")", "return", "aarch64_output_sve_cnt_immediate", "(", "\"dec\"", ",", "operands", ",", "-", "factor", ",", "nelts_per_vq", ")", ";", "else", "return", "aarch64_output_sve_cnt_immediate", "(", "\"inc\"", ",", "operands", ",", "factor", ",", "nelts_per_vq", ")", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "for", "an", "SVE", "vector", "INC", "or", "DEC", "instruction", ".", "OPERANDS", "gives", "the", "operands", "before", "the", "vector", "count", "and", "X", "is", "the", "value", "of", "the", "vector", "count", "operand", "itself", "." ]

[ "aarch64", "0", "\"dec\"", "\"inc\"" ]

[]

[ "<s>", "SDValue", "PTXTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "isVarArg", ")", "llvm_unreachable", "(", "\"PTX does not support varargs\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "PTXSubtarget", "&", "ST", "=", "getTargetMachine", "(", ")", ".", "getSubtarget", "<", "PTXSubtarget", ">", "(", ")", ";", "PTXMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "PTXMachineFunctionInfo", ">", "(", ")", ";", "PTXParamManager", "&", "PM", "=", "MFI", "->", "getParamManager", "(", ")", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "break", ";", "case", "CallingConv", "::", "PTX_Kernel", ":", "MFI", "->", "setKernel", "(", "true", ")", ";", "break", ";", "case", "CallingConv", "::", "PTX_Device", ":", "MFI", "->", "setKernel", "(", "false", ")", ";", "break", ";", "}", "if", "(", "MFI", "->", "isKernel", "(", ")", "||", "ST", ".", "useParamSpaceForDeviceArgs", "(", ")", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "assert", "(", "(", "!", "MFI", "->", "isKernel", "(", ")", "||", "Ins", "[", "i", "]", ".", "VT", "!=", "MVT", "::", "i1", ")", "&&", "\"Kernels cannot take pred operands\"", ")", ";", "unsigned", "ParamSize", "=", "Ins", "[", "i", "]", ".", "VT", ".", "getStoreSizeInBits", "(", ")", ";", "unsigned", "Param", "=", "PM", ".", "addArgumentParam", "(", "ParamSize", ")", ";", "const", "std", "::", "string", "&", "ParamName", "=", "PM", ".", "getParamName", "(", "Param", ")", ";", "SDValue", "ParamValue", "=", "DAG", ".", "getTargetExternalSymbol", "(", "ParamName", ".", "c_str", "(", ")", ",", "MVT", "::", "Other", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getNode", "(", "PTXISD", "::", "LOAD_PARAM", ",", "dl", ",", "Ins", "[", "i", "]", ".", "VT", ",", "Chain", ",", "ParamValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "}", "else", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Ins", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "EVT", "RegVT", "=", "Ins", "[", "i", "]", ".", "VT", ";", "TargetRegisterClass", "*", "TRC", "=", "getRegClassFor", "(", "RegVT", ")", ";", "SDValue", "Index", "=", "DAG", ".", "getTargetConstant", "(", "i", ",", "MVT", "::", "i32", ")", ";", "unsigned", "Reg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "TRC", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getNode", "(", "PTXISD", "::", "READ_PARAM", ",", "dl", ",", "RegVT", ",", "Chain", ",", "Index", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "MFI", "->", "addArgReg", "(", "Reg", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "ISD::InputArg", "\"PTX does not support varargs\"", "PTX", "PTX", "PTX", "PTX", "PTX", "\"Unsupported calling convention\"", "PTX", "PTX", "0", "MVT::i1", "\"Kernels cannot take pred operands\"", "MVT::Other", "PTXISD::LOAD_PARAM", "0", "MVT::i32", "PTXISD::READ_PARAM" ]

[]

[ "<s>", "bool", "ix86_agi_dependent", "(", "rtx_insn", "*", "set_insn", ",", "rtx_insn", "*", "use_insn", ")", "{", "int", "i", ";", "extract_insn_cached", "(", "use_insn", ")", ";", "for", "(", "i", "=", "recog_data", ".", "n_operands", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "if", "(", "MEM_P", "(", "recog_data", ".", "operand", "[", "i", "]", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "recog_data", ".", "operand", "[", "i", "]", ",", "0", ")", ";", "return", "modified_in_p", "(", "addr", ",", "set_insn", ")", "!=", "0", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "USE_INSN", "has", "a", "memory", "address", "with", "operands", "set", "by", "SET_INSN", "." ]

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

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "SrcReg", ")", ";", "unsigned", "CopyLocalOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyLocalOpcode", "=", "WebAssembly", "::", "COPY_LOCAL_F64", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyLocalOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_LOCAL_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_LOCAL_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_LOCAL_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_LOCAL_F64", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "unsigned", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "unsigned", "RegNo", "=", "Ctx", ".", "getRegisterInfo", "(", ")", "->", "getEncodingValue", "(", "Reg", ")", ";", "return", "RegNo", ";", "}", "else", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "}", "else", "if", "(", "MO", ".", "isFPImm", "(", ")", ")", "{", "return", "static_cast", "<", "unsigned", ">", "(", "APFloat", "(", "MO", ".", "getFPImm", "(", ")", ")", ".", "bitcastToAPInt", "(", ")", ".", "getHiBits", "(", "32", ")", ".", "getLimitedValue", "(", ")", ")", ";", "}", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "return", "getExprOpValue", "(", "MO", ".", "getExpr", "(", ")", ",", "Fixups", ",", "STI", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "SystemZHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "m", ",", "int", "Stalls", ")", "{", "return", "(", "fitsIntoCurrentGroup", "(", "m", ")", "?", "NoHazard", ":", "Hazard", ")", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "CF_ALU", ")", "{", "MI", "->", "getOperand", "(", "8", ")", ".", "setImm", "(", "0", ")", ";", "return", "true", ";", "}", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", "->", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setReg", "(", "Pred", "[", "2", "]", ".", "getReg", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "MIB", ".", "addReg", "(", "AMDGPU", "::", "PREDICATE_BIT", ",", "RegState", "::", "Implicit", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "R600", "8", "0", "1", "2" ]

[]

[ "<s>", "unsigned", "MipsInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MipsFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "Mips", "::", "CPURegsRegisterClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "Mips", "::", "GP", ")", ";", "RegInfo", ".", "addLiveIn", "(", "Mips", "::", "GP", ")", ";", "MipsFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "0", "Mips::CPURegsRegisterClass", "Mips::GP", "Mips::GP", "Mips" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "CellSPU" ]

[]

[ "<s>", "int", "call26_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "flag_pic", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "return", "SYMBOL_REF_MODEL", "(", "op", ")", "!=", "M32R_MODEL_LARGE", ";", "return", "TARGET_CALL26", ";", "}", "</s>" ]

[ "Return", "1", "if", "OP", "is", "a", "function", "that", "can", "be", "called", "with", "the", "`", "bl", "'", "insn", "." ]

[ "m32r", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "WebAssemblyFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "assert", "(", "!", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "&&", "hasFP", "(", "MF", ")", "&&", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", ")", ";", "const", "auto", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", "&&", "needsSPWriteback", "(", "MF", ",", "*", "MF", ".", "getFrameInfo", "(", ")", ")", ")", "{", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "writeSPToMemory", "(", "WebAssembly", "::", "SP32", ",", "MF", ",", "MBB", ",", "I", ",", "I", ",", "DL", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "WebAssembly", "WebAssembly", "0", "\"Call frame pseudos should only be used for dynamic stack adjustment\"", "WebAssembly", "WebAssembly::SP32" ]

[]

[ "<s>", "bool", "WebAssemblyRegNumbering", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "WebAssemblyFunctionInfo", "&", "MFI", "=", "*", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "MFI", ".", "initWARegs", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "ARGUMENT_I32", ":", "case", "WebAssembly", "::", "ARGUMENT_I64", ":", "case", "WebAssembly", "::", "ARGUMENT_F32", ":", "case", "WebAssembly", "::", "ARGUMENT_F64", ":", "MFI", ".", "setWAReg", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "unsigned", "NumArgRegs", "=", "MFI", ".", "getParams", "(", ")", ".", "size", "(", ")", ";", "unsigned", "NumVRegs", "=", "MF", ".", "getRegInfo", "(", ")", ".", "getNumVirtRegs", "(", ")", ";", "unsigned", "CurReg", "=", "0", ";", "for", "(", "unsigned", "VRegIdx", "=", "0", ";", "VRegIdx", "<", "NumVRegs", ";", "++", "VRegIdx", ")", "{", "unsigned", "VReg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "VRegIdx", ")", ";", "if", "(", "MRI", ".", "use_empty", "(", "VReg", ")", ")", "continue", ";", "if", "(", "MFI", ".", "getWAReg", "(", "VReg", ")", "==", "WebAssemblyFunctionInfo", "::", "UnusedReg", ")", "MFI", ".", "setWAReg", "(", "VReg", ",", "NumArgRegs", "+", "CurReg", "++", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Register Numbering **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly::ARGUMENT_I32", "WebAssembly::ARGUMENT_I64", "WebAssembly::ARGUMENT_F32", "WebAssembly::ARGUMENT_F64", "0", "1", "0", "0", "WebAssembly" ]

[]

[ "<s>", "void", "TOYFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TOYInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "TOYInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "int", "StackSize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TOY", "::", "ADDri", ")", ",", "TOY", "::", "SP", ")", ".", "addReg", "(", "TOY", "::", "SP", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "TOY", "TOY", "TOY::ADDri", "TOY::SP", "TOY::SP" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "relaxInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "MCInst", "&", "Res", ")", "const", "override", "{", "llvm_unreachable", "(", "\"CJGAsmBackend::relaxInstruction() unimplemented\"", ")", ";", "}", "</s>" ]

[ "Relax", "the", "instruction", "in", "the", "given", "fragment", "to", "the", "next", "wider", "instruction", "." ]

[ "CJG", "\"CJGAsmBackend::relaxInstruction() unimplemented\"" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "override", "{", "return", "Sparc", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "Sparc", "Sparc::NumTargetFixupKinds" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "CodeGenOpt", "::", "Level", "OptLevel", "=", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "FADD", ":", "return", "PerformADDCombine", "(", "N", ",", "DCI", ",", "STI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "PerformMULCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "PerformSHLCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "AND", ":", "return", "PerformANDCombine", "(", "N", ",", "DCI", ")", ";", "case", "ISD", "::", "UREM", ":", "case", "ISD", "::", "SREM", ":", "return", "PerformREMCombine", "(", "N", ",", "DCI", ",", "OptLevel", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "PerformSETCCCombine", "(", "N", ",", "DCI", ")", ";", "case", "NVPTXISD", "::", "StoreRetval", ":", "case", "NVPTXISD", "::", "StoreRetvalV2", ":", "case", "NVPTXISD", "::", "StoreRetvalV4", ":", "return", "PerformStoreRetvalCombine", "(", "N", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "ISD::ADD", "ISD::FADD", "ISD::MUL", "ISD::SHL", "ISD::AND", "ISD::UREM", "ISD::SREM", "ISD::SETCC", "NVPTXISD::StoreRetval", "NVPTXISD::StoreRetvalV2", "NVPTXISD::StoreRetvalV4" ]

[]

[ "<s>", "static", "void", "alpha_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "addr", ")", "{", "int", "basereg", "=", "31", ";", "HOST_WIDE_INT", "offset", "=", "0", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "AND", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "{", "offset", "=", "INTVAL", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LO_SUM", ")", "{", "const", "char", "*", "reloc16", ",", "*", "reloclo", ";", "rtx", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op1", ",", "0", ")", ")", "==", "UNSPEC", ")", "{", "op1", "=", "XEXP", "(", "op1", ",", "0", ")", ";", "switch", "(", "XINT", "(", "op1", ",", "1", ")", ")", "{", "case", "UNSPEC_DTPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"dtprel\"", ":", "\"dtprello\"", ")", ";", "break", ";", "case", "UNSPEC_TPREL", ":", "reloc16", "=", "NULL", ";", "reloclo", "=", "(", "alpha_tls_size", "==", "16", "?", "\"tprel\"", ":", "\"tprello\"", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"unknown relocation unspec\"", ")", ";", "return", ";", "}", "output_addr_const", "(", "file", ",", "XVECEXP", "(", "op1", ",", "0", ",", "0", ")", ")", ";", "}", "else", "{", "reloc16", "=", "\"gprel\"", ";", "reloclo", "=", "\"gprellow\"", ";", "output_addr_const", "(", "file", ",", "op1", ")", ";", "}", "if", "(", "offset", ")", "fprintf", "(", "file", ",", "\"+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"($%d)\\t\\t!%s\"", ",", "basereg", ",", "(", "basereg", "==", "29", "?", "reloc16", ":", "reloclo", ")", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "basereg", "=", "REGNO", "(", "addr", ")", ";", "break", ";", "case", "SUBREG", ":", "basereg", "=", "subreg_regno", "(", "addr", ")", ";", "break", ";", "case", "CONST_INT", ":", "offset", "=", "INTVAL", "(", "addr", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "XSTR", "(", "addr", ",", "0", ")", ")", ";", "return", ";", "case", "CONST", ":", "gcc_assert", "(", "TARGET_ABI_OPEN_VMS", "||", "this_is_asm_operands", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", ")", ";", "fprintf", "(", "file", ",", "\"%s+\"", "HOST_WIDE_INT_PRINT_DEC", ",", "XSTR", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "0", ")", ",", "0", ")", ",", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "addr", ",", "0", ")", ",", "1", ")", ")", ")", ";", "return", ";", "default", ":", "output_operand_lossage", "(", "\"invalid operand address\"", ")", ";", "return", ";", "}", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", "\"($%d)\"", ",", "offset", ",", "basereg", ")", ";", "}", "</s>" ]

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

[ "alpha", "31", "0", "0", "1", "1", "0", "1", "0", "0", "1", "16", "\"dtprel\"", "\"dtprello\"", "16", "\"tprel\"", "\"tprello\"", "\"unknown relocation unspec\"", "0", "0", "\"gprel\"", "\"gprellow\"", "\"+\"", "0", "\"($%d)\\t\\t!%s\"", "29", "\"%s\"", "0", "0", "0", "0", "\"%s+\"", "0", "0", "0", "0", "1", "\"invalid operand address\"", "\"($%d)\"" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "M68kRegisterInfo", "::", "getRegsForTailCall", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "&", "M68k", "::", "XR32_TCRegClass", ";", "}", "</s>" ]

[ "Returns", "a", "register", "class", "with", "registers", "that", "can", "be", "used", "in", "forming", "tail", "calls", "." ]

[ "M68k", "M68k", "M68k::XR32_TCRegClass" ]

[]

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

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

[ "SIC" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "emitStartOfAsmFile", "(", "Module", "&", "M", ")", "{", "IsTargetStreamerInitialized", "=", "false", ";", "}", "</s>" ]

[ "This", "virtual", "method", "can", "be", "overridden", "by", "targets", "that", "want", "to", "emit", "something", "at", "the", "start", "of", "their", "file", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "AsmVariant", ",", "ExtraCode", ",", "O", ")", ";", "case", "'X'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"0x\"", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'x'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "\"0x\"", "<<", "StringRef", "(", "utohexstr", "(", "MO", ".", "getImm", "(", ")", "&", "0xffff", ")", ")", ".", "lower", "(", ")", ";", "return", "false", ";", "case", "'d'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", ";", "return", "false", ";", "case", "'m'", ":", "if", "(", "(", "MO", ".", "getType", "(", ")", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "O", "<<", "MO", ".", "getImm", "(", ")", "-", "1", ";", "return", "false", ";", "case", "'z'", ":", "{", "if", "(", "MO", ".", "getType", "(", ")", "!=", "MachineOperand", "::", "MO_Immediate", ")", "return", "true", ";", "int64_t", "Val", "=", "MO", ".", "getImm", "(", ")", ";", "if", "(", "Val", ")", "O", "<<", "Val", ";", "else", "O", "<<", "\"$0\"", ";", "return", "false", ";", "}", "}", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "1", "0", "0", "\"0x\"", "\"0x\"", "0xffff", "1", "\"$0\"" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "PatmosFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STC", ".", "getInstrInfo", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "Size", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Patmos", "::", "ADJCALLSTACKDOWN", ")", "{", "Opcode", "=", "(", "Size", "<=", "0xFFF", ")", "?", "Patmos", "::", "SUBi", ":", "Patmos", "::", "SUBl", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "Patmos", "::", "ADJCALLSTACKUP", ")", "{", "Opcode", "=", "(", "Size", "<=", "0xFFF", ")", "?", "Patmos", "::", "ADDi", ":", "Patmos", "::", "ADDl", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unsupported pseudo instruction.\"", ")", ";", "}", "if", "(", "Size", ")", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ",", "Patmos", "::", "RSP", ")", ")", ".", "addReg", "(", "Patmos", "::", "RSP", ")", ".", "addImm", "(", "Size", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "Patmos", "Patmos", "0", "Patmos::ADJCALLSTACKDOWN", "0xFFF", "Patmos::SUBi", "Patmos::SUBl", "Patmos::ADJCALLSTACKUP", "0xFFF", "Patmos::ADDi", "Patmos::ADDl", "\"Unsupported pseudo instruction.\"", "Patmos::RSP", "Patmos::RSP" ]

[]

[ "<s>", "static", "void", "v850_insert_attributes", "(", "tree", "decl", ",", "tree", "*", "attr_ptr", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "data_area_stack", "&&", "data_area_stack", "->", "data_area", "&&", "current_function_decl", "==", "NULL_TREE", "&&", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "decl", ")", "==", "CONST_DECL", ")", "&&", "v850_get_data_area", "(", "decl", ")", "==", "DATA_AREA_NORMAL", ")", "v850_set_data_area", "(", "decl", ",", "data_area_stack", "->", "data_area", ")", ";", "if", "(", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_SDATA", "]", "==", "NULL", ")", "{", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_SDATA", "]", "=", "build_string", "(", "sizeof", "(", "\".sdata\"", ")", "-", "1", ",", "\".sdata\"", ")", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_ROSDATA", "]", "=", "build_string", "(", "sizeof", "(", "\".rosdata\"", ")", "-", "1", ",", "\".rosdata\"", ")", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_TDATA", "]", "=", "build_string", "(", "sizeof", "(", "\".tdata\"", ")", "-", "1", ",", "\".tdata\"", ")", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_ZDATA", "]", "=", "build_string", "(", "sizeof", "(", "\".zdata\"", ")", "-", "1", ",", "\".zdata\"", ")", ";", "GHS_default_section_names", "[", "(", "int", ")", "GHS_SECTION_KIND_ROZDATA", "]", "=", "build_string", "(", "sizeof", "(", "\".rozdata\"", ")", "-", "1", ",", "\".rozdata\"", ")", ";", "}", "if", "(", "current_function_decl", "==", "NULL_TREE", "&&", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", "||", "TREE_CODE", "(", "decl", ")", "==", "CONST_DECL", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "&&", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", "||", "DECL_INITIAL", "(", "decl", ")", ")", "&&", "!", "DECL_SECTION_NAME", "(", "decl", ")", ")", "{", "enum", "GHS_section_kind", "kind", "=", "GHS_SECTION_KIND_DEFAULT", ";", "tree", "chosen_section", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "kind", "=", "GHS_SECTION_KIND_TEXT", ";", "else", "{", "switch", "(", "v850_get_data_area", "(", "decl", ")", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "DATA_AREA_SDA", ":", "kind", "=", "(", "(", "TREE_READONLY", "(", "decl", ")", ")", "?", "GHS_SECTION_KIND_ROSDATA", ":", "GHS_SECTION_KIND_SDATA", ")", ";", "break", ";", "case", "DATA_AREA_TDA", ":", "kind", "=", "GHS_SECTION_KIND_TDATA", ";", "break", ";", "case", "DATA_AREA_ZDA", ":", "kind", "=", "(", "(", "TREE_READONLY", "(", "decl", ")", ")", "?", "GHS_SECTION_KIND_ROZDATA", ":", "GHS_SECTION_KIND_ZDATA", ")", ";", "break", ";", "case", "DATA_AREA_NORMAL", ":", "if", "(", "TREE_READONLY", "(", "decl", ")", ")", "kind", "=", "GHS_SECTION_KIND_RODATA", ";", "else", "if", "(", "DECL_INITIAL", "(", "decl", ")", ")", "kind", "=", "GHS_SECTION_KIND_DATA", ";", "else", "kind", "=", "GHS_SECTION_KIND_BSS", ";", "}", "}", "chosen_section", "=", "GHS_current_section_names", "[", "(", "int", ")", "kind", "]", ";", "if", "(", "chosen_section", "==", "NULL", ")", "chosen_section", "=", "GHS_default_section_names", "[", "(", "int", ")", "kind", "]", ";", "if", "(", "chosen_section", ")", "{", "DECL_SECTION_NAME", "(", "decl", ")", "=", "chosen_section", ";", "}", "}", "}", "</s>" ]

[ "Add", "data", "area", "to", "the", "given", "declaration", "if", "a", "ghs", "data", "area", "pragma", "is", "currently", "in", "effect", "(", "#", "pragma", "ghs", "startXXX/endXXX", ")", "." ]

[ "v850", "\".sdata\"", "1", "\".sdata\"", "\".rosdata\"", "1", "\".rosdata\"", "\".tdata\"", "1", "\".tdata\"", "\".zdata\"", "1", "\".zdata\"", "\".rozdata\"", "1", "\".rozdata\"" ]

[]

[ "<s>", "SDValue", "MipsSETargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHS", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MULHU", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Multu", ",", "false", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "Mult", ",", "true", ",", "false", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRem", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "lowerMulDiv", "(", "Op", ",", "MipsISD", "::", "DivRemU", ",", "true", ",", "true", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "lowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "return", "lowerINTRINSIC_W_CHAIN", "(", "Op", ",", "DAG", ")", ";", "}", "return", "MipsTargetLowering", "::", "LowerOperation", "(", "Op", ",", "DAG", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::SMUL_LOHI", "MipsISD::Mult", "ISD::UMUL_LOHI", "MipsISD::Multu", "ISD::MULHS", "MipsISD::Mult", "ISD::MULHU", "MipsISD::Multu", "ISD::MUL", "MipsISD::Mult", "ISD::SDIVREM", "MipsISD::DivRem", "ISD::UDIVREM", "MipsISD::DivRemU", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_W_CHAIN", "Mips" ]

[]

[ "<s>", "unsigned", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "FrameIndexValue", "*", "Value", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "unsigned", "i", "=", "0", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "Offset", ">=", "-", "4096", "&&", "Offset", "<=", "4095", ")", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "SP", "::", "I6", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "unsigned", "OffHi", "=", "(", "unsigned", ")", "Offset", ">>", "10U", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "SETHIi", ")", ",", "SP", "::", "G1", ")", ".", "addImm", "(", "OffHi", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "ADDrr", ")", ",", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "G1", ")", ".", "addReg", "(", "SP", "::", "I6", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "SP", "::", "G1", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", "&", "(", "(", "1", "<<", "10", ")", "-", "1", ")", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "0", "\"Instr doesn't have FrameIndex operand!\"", "1", "4096", "4095", "SP::I6", "1", "10U", "SP::SETHIi", "SP::G1", "SP::ADDrr", "SP::G1", "SP::G1", "SP::I6", "SP::G1", "1", "1", "10", "1", "0" ]

[]

[ "<s>", "unsigned", "XCoreRegisterInfo", "::", "getFrameRegister", "(", "MachineFunction", "&", "MF", ")", "const", "{", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "return", "FP", "?", "XCore", "::", "R10", ":", "XCore", "::", "SP", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R10", "XCore::SP" ]

[]

[ "<s>", "int", "pru_get_ctable_exact_base_index", "(", "unsigned", "HOST_WIDE_INT", "caddr", ")", "{", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "pru_ctable", ")", ";", "i", "++", ")", "{", "if", "(", "pru_ctable", "[", "i", "]", ".", "valid", "&&", "pru_ctable", "[", "i", "]", ".", "base", "==", "caddr", ")", "return", "i", ";", "}", "return", "-", "1", ";", "}", "</s>" ]

[ "Recognize", "a", "CTABLE", "base", "address", ".", "Return", "CTABLE", "entry", "index", ",", "or", "-1", "if", "base", "was", "not", "found", "in", "the", "pragma-filled", "pru_ctable", "." ]

[ "pru", "0", "1" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "scheduleMI", "(", "SUnit", "*", "SU", ",", "bool", "IsTopNode", ",", "bool", "IsBundled", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "?", "SU", "->", "getInstr", "(", ")", ":", "NULL", ";", "if", "(", "IsTopNode", ")", "{", "assert", "(", "(", "!", "SU", "||", "SU", "->", "isTopReady", "(", ")", ")", "&&", "\"node still has unscheduled dependencies\"", ")", ";", "if", "(", "!", "IsBundled", ")", "finishTopBundle", "(", ")", ";", "if", "(", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Pick top node SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") \"", ")", ";", "DEBUG", "(", "if", "(", "DFSResult", ")", "dbgs", "(", ")", "<<", "\" ILP: \"", "<<", "DFSResult", "->", "getILP", "(", "SU", ")", "<<", "\" Tree: \"", "<<", "DFSResult", "->", "getSubtreeID", "(", "SU", ")", "<<", "\" @\"", "<<", "DFSResult", "->", "getSubtreeLevel", "(", "DFSResult", "->", "getSubtreeID", "(", "SU", ")", ")", "<<", "'\\n'", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling \"", "<<", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "TopBundleMIs", ".", "push_back", "(", "MI", ")", ";", "}", "else", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling NOOP at top\\n\"", ")", ";", "TII", "->", "insertNoop", "(", "*", "BB", ",", "CurrentTop", ")", ";", "if", "(", "CurrentTop", "==", "RegionBegin", ")", "{", "RegionBegin", "=", "llvm", "::", "prior", "(", "CurrentTop", ")", ";", "}", "}", "}", "else", "{", "assert", "(", "(", "!", "SU", "||", "SU", "->", "isBottomReady", "(", ")", ")", "&&", "\"node still has unscheduled dependencies\"", ")", ";", "if", "(", "!", "IsBundled", ")", "finishBottomBundle", "(", ")", ";", "if", "(", "MI", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Pick bottom node SU(\"", "<<", "SU", "->", "NodeNum", "<<", "\") \"", ")", ";", "DEBUG", "(", "if", "(", "DFSResult", ")", "dbgs", "(", ")", "<<", "\" ILP: \"", "<<", "DFSResult", "->", "getILP", "(", "SU", ")", "<<", "\" Tree: \"", "<<", "DFSResult", "->", "getSubtreeID", "(", "SU", ")", "<<", "\" @\"", "<<", "DFSResult", "->", "getSubtreeLevel", "(", "DFSResult", "->", "getSubtreeID", "(", "SU", ")", ")", "<<", "'\\n'", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling \"", "<<", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "BottomBundleMIs", ".", "push_back", "(", "MI", ")", ";", "}", "else", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Scheduling NOOP at bottom\\n\"", ")", ";", "TII", "->", "insertNoop", "(", "*", "BB", ",", "CurrentBottom", ")", ";", "if", "(", "CurrentBottom", "==", "CurrentTop", ")", "{", "CurrentTop", "=", "llvm", "::", "prior", "(", "CurrentTop", ")", ";", "}", "if", "(", "CurrentBottom", "==", "RegionBegin", ")", "{", "RegionBegin", "=", "llvm", "::", "prior", "(", "CurrentBottom", ")", ";", "}", "CurrentBottom", "=", "llvm", "::", "prior", "(", "CurrentBottom", ")", ";", "}", "}", "}", "</s>" ]

[ "Move", "an", "instruction", "and", "update", "register", "pressure", "." ]

[ "Patmos", "\"node still has unscheduled dependencies\"", "\"Pick top node SU(\"", "\") \"", "\" ILP: \"", "\" Tree: \"", "\" @\"", "\"Scheduling \"", "\"Scheduling NOOP at top\\n\"", "\"node still has unscheduled dependencies\"", "\"Pick bottom node SU(\"", "\") \"", "\" ILP: \"", "\" Tree: \"", "\" @\"", "\"Scheduling \"", "\"Scheduling NOOP at bottom\\n\"" ]

[]

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

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

[ "AMDGPU", "\"R600 Packetizer\"" ]

[]

[ "<s>", "bool", "OpenRISCFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", "||", "MFI", "->", "isFrameAddressTaken", "(", ")", ")", ";", "}", "</s>" ]

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

[ "OpenRISC", "OpenRISC" ]

[]

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

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "getOpSize", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNo", ")", "const", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "unsigned", "SubReg", "=", "MO", ".", "getSubReg", "(", ")", ")", "{", "assert", "(", "RI", ".", "getRegSizeInBits", "(", "*", "RI", ".", "getSubClassWithSubReg", "(", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ",", "SubReg", ")", ")", ">=", "32", "&&", "\"Sub-dword subregs are not supported\"", ")", ";", "return", "RI", ".", "getSubRegIndexLaneMask", "(", "SubReg", ")", ".", "getNumLanes", "(", ")", "*", "4", ";", "}", "}", "return", "RI", ".", "getRegSizeInBits", "(", "*", "getOpRegClass", "(", "MI", ",", "OpNo", ")", ")", "/", "8", ";", "}", "</s>" ]

[ "This", "form", "should", "usually", "be", "preferred", "since", "it", "handles", "operands", "with", "unknown", "register", "classes", "." ]

[ "AMDGPU", "32", "\"Sub-dword subregs are not supported\"", "4", "8" ]

[]

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

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

[ "PowerPC", "PPC" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "reverseBranchCondition", "(", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "size", "(", ")", "==", "2", ")", "{", "ARMCC", "::", "CondCodes", "CC", "=", "(", "ARMCC", "::", "CondCodes", ")", "(", "int", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "Cond", "[", "0", "]", ".", "setImm", "(", "ARMCC", "::", "getOppositeCondition", "(", "CC", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "2", "ARMCC::CondCodes", "ARMCC::CondCodes", "0", "0", "ARMCC::getOppositeCondition" ]

[]

[ "<s>", "SDNode", "*", "HexagonDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectConstant", "(", "N", ")", ";", "case", "ISD", "::", "ConstantFP", ":", "return", "SelectConstantFP", "(", "N", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "SelectAdd", "(", "N", ")", ";", "case", "ISD", "::", "SHL", ":", "return", "SelectSHL", "(", "N", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "SelectLoad", "(", "N", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "SelectStore", "(", "N", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "SelectSelect", "(", "N", ")", ";", "case", "ISD", "::", "TRUNCATE", ":", "return", "SelectTruncate", "(", "N", ")", ";", "case", "ISD", "::", "MUL", ":", "return", "SelectMul", "(", "N", ")", ";", "case", "ISD", "::", "ZERO_EXTEND", ":", "return", "SelectZeroExtend", "(", "N", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "SelectIntrinsicWOChain", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "ISD::Constant", "ISD::ConstantFP", "ISD::ADD", "ISD::SHL", "ISD::LOAD", "ISD::STORE", "ISD::SELECT", "ISD::TRUNCATE", "ISD::MUL", "ISD::ZERO_EXTEND", "ISD::INTRINSIC_WO_CHAIN" ]

[]

[ "<s>", "bool", "isFI", "(", ")", "const", "{", "return", "isImmTy", "(", "ImmTyDppFi", ")", ";", "}", "</s>" ]

[ "isFI", "-", "Tests", "if", "this", "is", "a", "MO_FrameIndex", "operand", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "frv_insert_nop_in_packet", "(", "rtx_insn", "*", "insn", ")", "{", "struct", "frv_packet_group", "*", "packet_group", ";", "rtx_insn", "*", "last", ";", "packet_group", "=", "&", "frv_packet", ".", "groups", "[", "frv_unit_groups", "[", "frv_insn_unit", "(", "insn", ")", "]", "]", ";", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "last", ")", ")", "{", "insn", "=", "emit_insn_before", "(", "PATTERN", "(", "insn", ")", ",", "last", ")", ";", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", "=", "insn", ";", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "++", "]", "=", "last", ";", "}", "else", "{", "insn", "=", "emit_insn_after", "(", "PATTERN", "(", "insn", ")", ",", "last", ")", ";", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "++", "]", "=", "insn", ";", "}", "packet_group", "->", "insns", "[", "packet_group", "->", "num_insns", "++", "]", "=", "insn", ";", "}", "</s>" ]

[ "Insert", "INSN", "(", "a", "member", "of", "frv_nops", "[", "]", ")", "into", "the", "current", "packet", ".", "If", "the", "packet", "ends", "in", "a", "branch", "or", "call", ",", "insert", "the", "nop", "before", "it", ",", "otherwise", "add", "to", "the", "end", "." ]

[ "frv", "1", "1" ]

[]

[ "<s>", "bool", "x86_extended_QIreg_mentioned_p", "(", "rtx", "insn", ")", "{", "int", "i", ";", "extract_insn_cached", "(", "insn", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "recog_data", ".", "n_operands", ";", "i", "++", ")", "if", "(", "REG_P", "(", "recog_data", ".", "operand", "[", "i", "]", ")", "&&", "REGNO", "(", "recog_data", ".", "operand", "[", "i", "]", ")", ">=", "4", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "nonzero", "when", "QImode", "register", "that", "must", "be", "represented", "via", "REX", "prefix", "is", "used", "." ]

[ "i386", "0", "4" ]

[]

[ "<s>", "static", "bool", "mips_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "TARGET_OLDABI", "?", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", ":", "!", "IN_RANGE", "(", "int_size_in_bytes", "(", "type", ")", ",", "0", ",", "2", "*", "UNITS_PER_WORD", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_RETURN_IN_MEMORY", ".", "Under", "the", "old", "(", "i.e.", ",", "32", "and", "O64", "ABIs", ")", "all", "BLKmode", "objects", "are", "returned", "in", "memory", ".", "Under", "the", "new", "(", "N32", "and", "64-bit", "MIPS", "ABIs", ")", "small", "structures", "are", "returned", "in", "a", "register", ".", "Objects", "with", "varying", "size", "must", "still", "be", "returned", "in", "memory", ",", "of", "course", "." ]

[ "mips", "0", "2" ]

[]

[ "<s>", "void", "MipsRegisterInfo", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MipsFunctionInfo", "*", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "if", "(", "MipsFI", "->", "needGPSaveRestore", "(", ")", ")", "MFI", "->", "setObjectOffset", "(", "MipsFI", "->", "getGPFI", "(", ")", ",", "MipsFI", "->", "getGPStackOffset", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "quad_address_p", "(", "rtx", "addr", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "rtx", "op0", ",", "op1", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "16", ")", "return", "false", ";", "if", "(", "legitimate_indirect_address_p", "(", "addr", ",", "strict", ")", ")", "return", "true", ";", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", "&&", "!", "mode_supports_dq_form", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "address_is_prefixed", "(", "addr", ",", "mode", ",", "NON_PREFIXED_DQ", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "PLUS", ")", "return", "false", ";", "op0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", "||", "!", "INT_REG_OK_FOR_BASE_P", "(", "op0", ",", "strict", ")", ")", "return", "false", ";", "op1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "op1", ")", ")", "return", "false", ";", "return", "quad_address_offset_p", "(", "INTVAL", "(", "op1", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "ADDR", "is", "an", "acceptable", "address", "for", "a", "quad", "memory", "operation", "of", "mode", "MODE", "(", "either", "LQ/STQ", "for", "general", "purpose", "registers", ",", "or", "LXV/STXV", "for", "vector", "registers", "under", "ISA", "3.0", ".", "GPR_P", "is", "true", "if", "this", "address", "is", "intended", "for", "LQ/STQ", ".", "If", "it", "is", "false", ",", "the", "address", "is", "intended", "for", "the", "ISA", "3.0", "LXV/STXV", "instruction", "." ]

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

[]