Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 1 | //===- CodeEmitterGen.cpp - Code Emitter Generator ------------------------===// |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 01d4582 | 2003-10-20 20:20:30 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 3060910 | 2007-12-29 20:37:13 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 01d4582 | 2003-10-20 20:20:30 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 9 | // |
Misha Brukman | 4e4f863 | 2004-08-04 22:07:54 +0000 | [diff] [blame] | 10 | // CodeEmitterGen uses the descriptions of instructions and their fields to |
| 11 | // construct an automated code emitter: a function that, given a MachineInstr, |
| 12 | // returns the (currently, 32-bit unsigned) value of the instruction. |
Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 16 | #include "CodeEmitterGen.h" |
Misha Brukman | d7a5b28 | 2004-08-09 19:10:43 +0000 | [diff] [blame] | 17 | #include "CodeGenTarget.h" |
Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 18 | #include "Record.h" |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/StringExtras.h" |
Jim Grosbach | ab3d00e | 2010-11-02 17:35:25 +0000 | [diff] [blame] | 20 | #include "llvm/Support/CommandLine.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 21 | #include "llvm/Support/Debug.h" |
Chris Lattner | 2082ebe | 2004-08-01 03:55:39 +0000 | [diff] [blame] | 22 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 23 | |
Jim Grosbach | 60aaa76 | 2010-11-03 23:38:14 +0000 | [diff] [blame] | 24 | // FIXME: Somewhat hackish to use a command line option for this. There should |
| 25 | // be a CodeEmitter class in the Target.td that controls this sort of thing |
| 26 | // instead. |
Jim Grosbach | ab3d00e | 2010-11-02 17:35:25 +0000 | [diff] [blame] | 27 | static cl::opt<bool> |
Jim Grosbach | 60aaa76 | 2010-11-03 23:38:14 +0000 | [diff] [blame] | 28 | MCEmitter("mc-emitter", |
Jim Grosbach | ab3d00e | 2010-11-02 17:35:25 +0000 | [diff] [blame] | 29 | cl::desc("Generate CodeEmitter for use with the MC library."), |
| 30 | cl::init(false)); |
| 31 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 32 | void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) { |
| 33 | for (std::vector<Record*>::iterator I = Insts.begin(), E = Insts.end(); |
| 34 | I != E; ++I) { |
| 35 | Record *R = *I; |
Jakob Stoklund Olesen | 65766ce | 2010-07-02 21:44:22 +0000 | [diff] [blame] | 36 | if (R->getValueAsString("Namespace") == "TargetOpcode") |
| 37 | continue; |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 38 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 39 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 40 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 41 | unsigned numBits = BI->getNumBits(); |
| 42 | BitsInit *NewBI = new BitsInit(numBits); |
| 43 | for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) { |
| 44 | unsigned bitSwapIdx = numBits - bit - 1; |
| 45 | Init *OrigBit = BI->getBit(bit); |
| 46 | Init *BitSwap = BI->getBit(bitSwapIdx); |
| 47 | NewBI->setBit(bit, BitSwap); |
| 48 | NewBI->setBit(bitSwapIdx, OrigBit); |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 49 | } |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 50 | if (numBits % 2) { |
| 51 | unsigned middle = (numBits + 1) / 2; |
| 52 | NewBI->setBit(middle, BI->getBit(middle)); |
| 53 | } |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 54 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 55 | // Update the bits in reversed order so that emitInstrOpBits will get the |
| 56 | // correct endianness. |
| 57 | R->getValue("Inst")->setValue(NewBI); |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 58 | } |
| 59 | } |
| 60 | |
Jim Laskey | cb12903 | 2006-07-13 22:17:08 +0000 | [diff] [blame] | 61 | // If the VarBitInit at position 'bit' matches the specified variable then |
| 62 | // return the variable bit position. Otherwise return -1. |
Dan Gohman | 9b03da6 | 2009-12-15 20:21:44 +0000 | [diff] [blame] | 63 | int CodeEmitterGen::getVariableBit(const std::string &VarName, |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 64 | BitsInit *BI, int bit) { |
Chris Lattner | 98e969a | 2010-11-15 06:42:13 +0000 | [diff] [blame] | 65 | if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) |
| 66 | if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getVariable())) |
| 67 | if (VI->getName() == VarName) |
| 68 | return VBI->getBitNum(); |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 69 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 70 | return -1; |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 71 | } |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 72 | |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 73 | void CodeEmitterGen:: |
| 74 | AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName, |
| 75 | unsigned &NumberedOp, |
| 76 | std::string &Case, CodeGenTarget &Target) { |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 77 | CodeGenInstruction &CGI = Target.getInstruction(R); |
| 78 | |
Chris Lattner | 8ae082b | 2010-11-15 07:09:28 +0000 | [diff] [blame] | 79 | // Determine if VarName actually contributes to the Inst encoding. |
| 80 | int bit = BI->getNumBits()-1; |
| 81 | |
| 82 | // Scan for a bit that this contributed to. |
| 83 | for (; bit >= 0; ) { |
| 84 | if (getVariableBit(VarName, BI, bit) != -1) |
| 85 | break; |
| 86 | |
| 87 | --bit; |
| 88 | } |
| 89 | |
| 90 | // If we found no bits, ignore this value, otherwise emit the call to get the |
| 91 | // operand encoding. |
| 92 | if (bit < 0) return; |
| 93 | |
| 94 | // If the operand matches by name, reference according to that |
| 95 | // operand number. Non-matching operands are assumed to be in |
| 96 | // order. |
| 97 | unsigned OpIdx; |
| 98 | if (CGI.Operands.hasOperandNamed(VarName, OpIdx)) { |
| 99 | // Get the machine operand number for the indicated operand. |
| 100 | OpIdx = CGI.Operands[OpIdx].MIOperandNo; |
| 101 | assert(!CGI.Operands.isFlatOperandNotEmitted(OpIdx) && |
| 102 | "Explicitly used operand also marked as not emitted!"); |
| 103 | } else { |
| 104 | /// If this operand is not supposed to be emitted by the |
| 105 | /// generated emitter, skip it. |
| 106 | while (CGI.Operands.isFlatOperandNotEmitted(NumberedOp)) |
| 107 | ++NumberedOp; |
| 108 | OpIdx = NumberedOp++; |
| 109 | } |
| 110 | |
| 111 | std::pair<unsigned, unsigned> SO = CGI.Operands.getSubOperandNumber(OpIdx); |
| 112 | std::string &EncoderMethodName = CGI.Operands[SO.first].EncoderMethodName; |
| 113 | |
| 114 | // If the source operand has a custom encoder, use it. This will |
| 115 | // get the encoding for all of the suboperands. |
| 116 | if (!EncoderMethodName.empty()) { |
| 117 | // A custom encoder has all of the information for the |
| 118 | // sub-operands, if there are more than one, so only |
| 119 | // query the encoder once per source operand. |
| 120 | if (SO.second == 0) { |
| 121 | Case += " // op: " + VarName + "\n" + |
| 122 | " op = " + EncoderMethodName + "(MI, " + utostr(OpIdx); |
| 123 | if (MCEmitter) |
| 124 | Case += ", Fixups"; |
| 125 | Case += ");\n"; |
| 126 | } |
| 127 | } else { |
| 128 | Case += " // op: " + VarName + "\n" + |
| 129 | " op = getMachineOpValue(MI, MI.getOperand(" + utostr(OpIdx) + ")"; |
| 130 | if (MCEmitter) |
| 131 | Case += ", Fixups"; |
| 132 | Case += ");\n"; |
| 133 | } |
| 134 | |
| 135 | for (; bit >= 0; ) { |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 136 | int varBit = getVariableBit(VarName, BI, bit); |
| 137 | |
| 138 | // If this bit isn't from a variable, skip it. |
| 139 | if (varBit == -1) { |
| 140 | --bit; |
| 141 | continue; |
| 142 | } |
| 143 | |
| 144 | // Figure out the consequtive range of bits covered by this operand, in |
| 145 | // order to generate better encoding code. |
| 146 | int beginInstBit = bit; |
| 147 | int beginVarBit = varBit; |
| 148 | int N = 1; |
| 149 | for (--bit; bit >= 0;) { |
| 150 | varBit = getVariableBit(VarName, BI, bit); |
| 151 | if (varBit == -1 || varBit != (beginVarBit - N)) break; |
| 152 | ++N; |
| 153 | --bit; |
| 154 | } |
Chris Lattner | 8ae082b | 2010-11-15 07:09:28 +0000 | [diff] [blame] | 155 | |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 156 | unsigned opMask = ~0U >> (32-N); |
| 157 | int opShift = beginVarBit - N + 1; |
| 158 | opMask <<= opShift; |
| 159 | opShift = beginInstBit - beginVarBit; |
| 160 | |
| 161 | if (opShift > 0) { |
| 162 | Case += " Value |= (op & " + utostr(opMask) + "U) << " + |
| 163 | itostr(opShift) + ";\n"; |
| 164 | } else if (opShift < 0) { |
| 165 | Case += " Value |= (op & " + utostr(opMask) + "U) >> " + |
| 166 | itostr(-opShift) + ";\n"; |
| 167 | } else { |
| 168 | Case += " Value |= op & " + utostr(opMask) + "U;\n"; |
| 169 | } |
| 170 | } |
| 171 | } |
| 172 | |
| 173 | |
| 174 | std::string CodeEmitterGen::getInstructionCase(Record *R, |
| 175 | CodeGenTarget &Target) { |
| 176 | std::string Case; |
| 177 | |
| 178 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
| 179 | const std::vector<RecordVal> &Vals = R->getValues(); |
| 180 | unsigned NumberedOp = 0; |
| 181 | |
| 182 | // Loop over all of the fields in the instruction, determining which are the |
| 183 | // operands to the instruction. |
| 184 | for (unsigned i = 0, e = Vals.size(); i != e; ++i) { |
| 185 | // Ignore fixed fields in the record, we're looking for values like: |
| 186 | // bits<5> RST = { ?, ?, ?, ?, ? }; |
| 187 | if (Vals[i].getPrefix() || Vals[i].getValue()->isComplete()) |
| 188 | continue; |
| 189 | |
| 190 | AddCodeToMergeInOperand(R, BI, Vals[i].getName(), NumberedOp, Case, Target); |
| 191 | } |
| 192 | |
| 193 | std::string PostEmitter = R->getValueAsString("PostEncoderMethod"); |
| 194 | if (!PostEmitter.empty()) |
| 195 | Case += " Value = " + PostEmitter + "(MI, Value);\n"; |
| 196 | |
| 197 | return Case; |
| 198 | } |
| 199 | |
Daniel Dunbar | 1a55180 | 2009-07-03 00:10:29 +0000 | [diff] [blame] | 200 | void CodeEmitterGen::run(raw_ostream &o) { |
Chris Lattner | 67db883 | 2010-12-13 00:23:57 +0000 | [diff] [blame^] | 201 | CodeGenTarget Target(Records); |
Chris Lattner | 048c00d | 2003-08-01 04:38:18 +0000 | [diff] [blame] | 202 | std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction"); |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 203 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 204 | // For little-endian instruction bit encodings, reverse the bit order |
| 205 | if (Target.isLittleEndianEncoding()) reverseBits(Insts); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 206 | |
Chris Lattner | 0e5e49e | 2003-08-06 04:36:35 +0000 | [diff] [blame] | 207 | EmitSourceFileHeader("Machine Code Emitter", o); |
Misha Brukman | e2ba778 | 2004-08-10 18:31:01 +0000 | [diff] [blame] | 208 | std::string Namespace = Insts[0]->getValueAsString("Namespace") + "::"; |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 209 | |
Chris Lattner | f650278 | 2010-03-19 00:34:35 +0000 | [diff] [blame] | 210 | const std::vector<const CodeGenInstruction*> &NumberedInstructions = |
| 211 | Target.getInstructionsByEnumValue(); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 212 | |
Misha Brukman | ad346ad | 2004-08-10 20:54:58 +0000 | [diff] [blame] | 213 | // Emit function declaration |
Jim Grosbach | 60aaa76 | 2010-11-03 23:38:14 +0000 | [diff] [blame] | 214 | o << "unsigned " << Target.getName(); |
| 215 | if (MCEmitter) |
| 216 | o << "MCCodeEmitter::getBinaryCodeForInstr(const MCInst &MI,\n" |
| 217 | << " SmallVectorImpl<MCFixup> &Fixups) const {\n"; |
| 218 | else |
| 219 | o << "CodeEmitter::getBinaryCodeForInstr(const MachineInstr &MI) const {\n"; |
Misha Brukman | ad346ad | 2004-08-10 20:54:58 +0000 | [diff] [blame] | 220 | |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 221 | // Emit instruction base values |
| 222 | o << " static const unsigned InstBits[] = {\n"; |
Chris Lattner | f650278 | 2010-03-19 00:34:35 +0000 | [diff] [blame] | 223 | for (std::vector<const CodeGenInstruction*>::const_iterator |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 224 | IN = NumberedInstructions.begin(), |
| 225 | EN = NumberedInstructions.end(); |
| 226 | IN != EN; ++IN) { |
| 227 | const CodeGenInstruction *CGI = *IN; |
| 228 | Record *R = CGI->TheDef; |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 229 | |
Jakob Stoklund Olesen | 65766ce | 2010-07-02 21:44:22 +0000 | [diff] [blame] | 230 | if (R->getValueAsString("Namespace") == "TargetOpcode") { |
Evan Cheng | bc95b23 | 2008-09-17 06:29:52 +0000 | [diff] [blame] | 231 | o << " 0U,\n"; |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 232 | continue; |
| 233 | } |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 234 | |
Chris Lattner | 6f334ad | 2003-08-01 04:46:24 +0000 | [diff] [blame] | 235 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 236 | |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 237 | // Start by filling in fixed values. |
Reid Spencer | fa3e3b9 | 2006-11-03 01:48:30 +0000 | [diff] [blame] | 238 | unsigned Value = 0; |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 239 | for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) { |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 240 | if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1))) |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 241 | Value |= B->getValue() << (e-i-1); |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 242 | } |
Evan Cheng | bc95b23 | 2008-09-17 06:29:52 +0000 | [diff] [blame] | 243 | o << " " << Value << "U," << '\t' << "// " << R->getName() << "\n"; |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 244 | } |
Evan Cheng | bc95b23 | 2008-09-17 06:29:52 +0000 | [diff] [blame] | 245 | o << " 0U\n };\n"; |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 246 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 247 | // Map to accumulate all the cases. |
| 248 | std::map<std::string, std::vector<std::string> > CaseMap; |
Jim Grosbach | 8b892ae | 2010-10-07 16:56:28 +0000 | [diff] [blame] | 249 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 250 | // Construct all cases statement for each opcode |
| 251 | for (std::vector<Record*>::iterator IC = Insts.begin(), EC = Insts.end(); |
| 252 | IC != EC; ++IC) { |
| 253 | Record *R = *IC; |
Jakob Stoklund Olesen | 65766ce | 2010-07-02 21:44:22 +0000 | [diff] [blame] | 254 | if (R->getValueAsString("Namespace") == "TargetOpcode") |
| 255 | continue; |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 256 | const std::string &InstName = R->getName(); |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 257 | std::string Case = getInstructionCase(R, Target); |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 258 | |
Chris Lattner | 1620117 | 2010-11-15 06:59:17 +0000 | [diff] [blame] | 259 | CaseMap[Case].push_back(InstName); |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 260 | } |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 261 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 262 | // Emit initial function code |
| 263 | o << " const unsigned opcode = MI.getOpcode();\n" |
| 264 | << " unsigned Value = InstBits[opcode];\n" |
Evan Cheng | e3e3626 | 2008-09-07 09:00:57 +0000 | [diff] [blame] | 265 | << " unsigned op = 0;\n" |
Evan Cheng | acff339 | 2008-09-02 06:51:36 +0000 | [diff] [blame] | 266 | << " op = op; // suppress warning\n" |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 267 | << " switch (opcode) {\n"; |
| 268 | |
| 269 | // Emit each case statement |
| 270 | std::map<std::string, std::vector<std::string> >::iterator IE, EE; |
| 271 | for (IE = CaseMap.begin(), EE = CaseMap.end(); IE != EE; ++IE) { |
| 272 | const std::string &Case = IE->first; |
| 273 | std::vector<std::string> &InstList = IE->second; |
| 274 | |
| 275 | for (int i = 0, N = InstList.size(); i < N; i++) { |
| 276 | if (i) o << "\n"; |
| 277 | o << " case " << Namespace << InstList[i] << ":"; |
| 278 | } |
| 279 | o << " {\n"; |
| 280 | o << Case; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 281 | o << " break;\n" |
| 282 | << " }\n"; |
| 283 | } |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 284 | |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 285 | // Default case: unhandled opcode |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 286 | o << " default:\n" |
Torok Edwin | 804e0fe | 2009-07-08 19:04:27 +0000 | [diff] [blame] | 287 | << " std::string msg;\n" |
| 288 | << " raw_string_ostream Msg(msg);\n" |
| 289 | << " Msg << \"Not supported instr: \" << MI;\n" |
Chris Lattner | 75361b6 | 2010-04-07 22:58:41 +0000 | [diff] [blame] | 290 | << " report_fatal_error(Msg.str());\n" |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 291 | << " }\n" |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 292 | << " return Value;\n" |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 293 | << "}\n\n"; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 294 | } |