| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_codemaker.hxx" |
| |
| #include "classfile.hxx" |
| |
| #include "codemaker/global.hxx" |
| #include "codemaker/options.hxx" |
| #include "codemaker/unotype.hxx" |
| |
| #include "boost/static_assert.hpp" |
| #include "osl/diagnose.h" |
| #include "rtl/string.h" |
| #include "rtl/string.hxx" |
| #include "sal/types.h" |
| |
| #include <map> |
| #include <utility> |
| #include <vector> |
| |
| using codemaker::javamaker::ClassFile; |
| |
| namespace { |
| |
| void appendU1(std::vector< unsigned char > & stream, sal_uInt8 data) { |
| stream.push_back(static_cast< unsigned char >(data)); |
| } |
| |
| void appendU2(std::vector< unsigned char > & stream, sal_uInt16 data) { |
| stream.push_back(static_cast< unsigned char >(data >> 8)); |
| stream.push_back(static_cast< unsigned char >(data & 0xFF)); |
| } |
| |
| void appendU4(std::vector< unsigned char > & stream, sal_uInt32 data) { |
| stream.push_back(static_cast< unsigned char >(data >> 24)); |
| stream.push_back(static_cast< unsigned char >((data >> 16) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >((data >> 8) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >(data & 0xFF)); |
| } |
| |
| void appendU8(std::vector< unsigned char > & stream, sal_uInt64 data) { |
| stream.push_back(static_cast< unsigned char >(data >> 56)); |
| stream.push_back(static_cast< unsigned char >((data >> 48) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >((data >> 40) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >((data >> 32) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >((data >> 24) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >((data >> 16) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >((data >> 8) & 0xFF)); |
| stream.push_back(static_cast< unsigned char >(data & 0xFF)); |
| } |
| |
| void appendStream( |
| std::vector< unsigned char > & stream, |
| std::vector< unsigned char > const & data) |
| { |
| stream.insert(stream.end(), data.begin(), data.end()); |
| } |
| |
| void write(FileStream & file, void const * buffer, sal_uInt64 size) { |
| if (!file.write(buffer, size)) { |
| throw CannotDumpException( |
| rtl::OString(RTL_CONSTASCII_STRINGPARAM("Error writing file"))); |
| } |
| } |
| |
| void writeU1(FileStream & file, sal_uInt8 data) { |
| unsigned char buf[] = { static_cast< unsigned char >(data) }; |
| write(file, &buf, sizeof buf); |
| } |
| |
| void writeU2(FileStream & file, sal_uInt16 data) { |
| unsigned char buf[] = { |
| static_cast< unsigned char >(data >> 8), |
| static_cast< unsigned char >(data & 0xFF) }; |
| write(file, buf, sizeof buf); |
| } |
| |
| void writeU4(FileStream & file, sal_uInt32 data) { |
| unsigned char buf[] = { |
| static_cast< unsigned char >(data >> 24), |
| static_cast< unsigned char >((data >> 16) & 0xFF), |
| static_cast< unsigned char >((data >> 8) & 0xFF), |
| static_cast< unsigned char >(data & 0xFF) }; |
| write(file, buf, sizeof buf); |
| } |
| |
| void writeStream(FileStream & file, std::vector< unsigned char > const & stream) |
| { |
| std::vector< unsigned char >::size_type n = stream.size(); |
| BOOST_STATIC_ASSERT( |
| sizeof (std::vector< unsigned char >::size_type) |
| <= sizeof (sal_uInt64)); |
| // both unsigned integral, so sizeof is a practically sufficient |
| // approximation of std::numeric_limits<T1>::max() <= |
| // std::numeric_limits<T2>::max() |
| if (n != 0) { |
| write(file, &stream[0], static_cast< sal_uInt64 >(n)); |
| } |
| } |
| |
| } |
| |
| ClassFile::Code::~Code() {} |
| |
| void ClassFile::Code::instrAastore() { |
| // aastore: |
| appendU1(m_code, 0x53); |
| } |
| |
| void ClassFile::Code::instrAconstNull() { |
| // aconst_null: |
| appendU1(m_code, 0x01); |
| } |
| |
| void ClassFile::Code::instrAnewarray(rtl::OString const & type) { |
| // anewarray <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xBD); |
| appendU2(m_code, m_classFile.addClassInfo(type)); |
| } |
| |
| void ClassFile::Code::instrAreturn() { |
| // areturn: |
| appendU1(m_code, 0xB0); |
| } |
| |
| void ClassFile::Code::instrAthrow() { |
| // athrow: |
| appendU1(m_code, 0xBF); |
| } |
| |
| void ClassFile::Code::instrCheckcast(rtl::OString const & type) { |
| // checkcast <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xC0); |
| appendU2(m_code, m_classFile.addClassInfo(type)); |
| } |
| |
| void ClassFile::Code::instrDup() { |
| // dup: |
| appendU1(m_code, 0x59); |
| } |
| |
| void ClassFile::Code::instrGetstatic( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| // getstatic <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xB2); |
| appendU2(m_code, m_classFile.addFieldrefInfo(type, name, descriptor)); |
| } |
| |
| ClassFile::Code::Branch ClassFile::Code::instrIfAcmpne() { |
| // if_acmpne <branchbyte1> <branchbyte2>: |
| Branch branch = m_code.size(); |
| appendU1(m_code, 0xA6); |
| appendU2(m_code, 0); |
| return branch; |
| } |
| |
| ClassFile::Code::Branch ClassFile::Code::instrIfeq() { |
| // ifeq <branchbyte1> <branchbyte2>: |
| Branch branch = m_code.size(); |
| appendU1(m_code, 0x99); |
| appendU2(m_code, 0); |
| return branch; |
| } |
| |
| ClassFile::Code::Branch ClassFile::Code::instrIfnull() { |
| // ifnull <branchbyte1> <branchbyte2>: |
| Branch branch = m_code.size(); |
| appendU1(m_code, 0xC6); |
| appendU2(m_code, 0); |
| return branch; |
| } |
| |
| void ClassFile::Code::instrInstanceof(rtl::OString const & type) { |
| // instanceof <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xC1); |
| appendU2(m_code, m_classFile.addClassInfo(type)); |
| } |
| |
| void ClassFile::Code::instrInvokeinterface( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor, sal_uInt8 args) |
| { |
| // invokeinterface <indexbyte1> <indexbyte2> <nargs> 0: |
| appendU1(m_code, 0xB9); |
| appendU2( |
| m_code, m_classFile.addInterfaceMethodrefInfo(type, name, descriptor)); |
| appendU1(m_code, args); |
| appendU1(m_code, 0); |
| } |
| |
| void ClassFile::Code::instrInvokespecial( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| // invokespecial <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xB7); |
| appendU2(m_code, m_classFile.addMethodrefInfo(type, name, descriptor)); |
| } |
| |
| void ClassFile::Code::instrInvokestatic( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| // invokestatic <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xB8); |
| appendU2(m_code, m_classFile.addMethodrefInfo(type, name, descriptor)); |
| } |
| |
| void ClassFile::Code::instrInvokevirtual( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| // invokevirtual <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xB6); |
| appendU2(m_code, m_classFile.addMethodrefInfo(type, name, descriptor)); |
| } |
| |
| void ClassFile::Code::instrLookupswitch( |
| Code const * defaultBlock, |
| std::list< std::pair< sal_Int32, Code * > > const & blocks) |
| { |
| // lookupswitch <0--3 byte pad> <defaultbyte1> <defaultbyte2> <defaultbyte3> |
| // <defaultbyte4> <npairs1> <npairs2> <npairs3> <npairs4> |
| // <match--offset pairs...>: |
| std::list< std::pair< sal_Int32, Code * > >::size_type size = blocks.size(); |
| if (size > SAL_MAX_INT32) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Lookup-switch too large for Java class file format"))); |
| } |
| Position pos1 = m_code.size(); |
| appendU1(m_code, 0xAB); |
| int pad = (pos1 + 1) % 4; |
| {for (int i = 0; i < pad; ++i) { |
| appendU1(m_code, 0); |
| }} |
| Position pos2 = pos1 + 1 + pad + 8 + blocks.size() * 8; //FIXME: overflow |
| appendU4(m_code, static_cast< sal_uInt32 >(pos2 - pos1)); //FIXME: overflow |
| pos2 += defaultBlock->m_code.size(); //FIXME: overflow |
| appendU4(m_code, static_cast< sal_uInt32 >(size)); |
| {for (std::list< std::pair< sal_Int32, Code * > >::const_iterator i( |
| blocks.begin()); |
| i != blocks.end(); ++i) |
| { |
| appendU4(m_code, static_cast< sal_uInt32 >(i->first)); |
| appendU4(m_code, static_cast< sal_uInt32 >(pos2 - pos1)); |
| //FIXME: overflow |
| pos2 += i->second->m_code.size(); //FIXME: overflow |
| }} |
| appendStream(m_code, defaultBlock->m_code); |
| {for (std::list< std::pair< sal_Int32, Code * > >::const_iterator i( |
| blocks.begin()); |
| i != blocks.end(); ++i) |
| { |
| appendStream(m_code, i->second->m_code); |
| }} |
| } |
| |
| void ClassFile::Code::instrNew(rtl::OString const & type) { |
| // new <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xBB); |
| appendU2(m_code, m_classFile.addClassInfo(type)); |
| } |
| |
| void ClassFile::Code::instrNewarray(codemaker::UnoType::Sort sort) { |
| OSL_ASSERT( |
| sort >= codemaker::UnoType::SORT_BOOLEAN |
| && sort <= codemaker::UnoType::SORT_CHAR); |
| // newarray <atype>: |
| appendU1(m_code, 0xBC); |
| static sal_uInt8 const atypes[codemaker::UnoType::SORT_CHAR] = { |
| 0x04, 0x08, 0x09, 0x09, 0x0A, 0x0A, 0x0B, 0x0B, 0x06, 0x07, 0x05 }; |
| appendU1(m_code, atypes[sort - 1]); |
| } |
| |
| void ClassFile::Code::instrPop() { |
| // pop: |
| appendU1(m_code, 0x57); |
| } |
| |
| void ClassFile::Code::instrPutfield( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| // putfield <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xB5); |
| appendU2(m_code, m_classFile.addFieldrefInfo(type, name, descriptor)); |
| } |
| |
| void ClassFile::Code::instrPutstatic( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| // putstatic <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xB3); |
| appendU2(m_code, m_classFile.addFieldrefInfo(type, name, descriptor)); |
| } |
| |
| void ClassFile::Code::instrReturn() { |
| // return: |
| appendU1(m_code, 0xB1); |
| } |
| |
| void ClassFile::Code::instrSwap() { |
| // swap: |
| appendU1(m_code, 0x5F); |
| } |
| |
| void ClassFile::Code::instrTableswitch( |
| Code const * defaultBlock, sal_Int32 low, |
| std::list< Code * > const & blocks) |
| { |
| // tableswitch <0--3 byte pad> <defaultbyte1> <defaultbyte2> <defaultbyte3> |
| // <defaultbyte4> <lowbyte1> <lowbyte2> <lowbyte3> <lowbyte4> <highbyte1> |
| // <highbyte2> <highbyte3> <highbyte4> <jump offsets...>: |
| Position pos1 = m_code.size(); |
| appendU1(m_code, 0xAA); |
| int pad = (pos1 + 1) % 4; |
| {for (int i = 0; i < pad; ++i) { |
| appendU1(m_code, 0); |
| }} |
| std::list< Code * >::size_type size = blocks.size(); |
| Position pos2 = pos1 + 1 + pad + 12 + size * 4; //FIXME: overflow |
| sal_uInt32 defaultOffset = static_cast< sal_uInt32 >(pos2 - pos1); |
| //FIXME: overflow |
| appendU4(m_code, defaultOffset); |
| pos2 += defaultBlock->m_code.size(); //FIXME: overflow |
| appendU4(m_code, static_cast< sal_uInt32 >(low)); |
| appendU4(m_code, static_cast< sal_uInt32 >(low + (size - 1))); |
| {for (std::list< Code * >::const_iterator i(blocks.begin()); |
| i != blocks.end(); ++i) |
| { |
| if (*i == 0) { |
| appendU4(m_code, defaultOffset); |
| } else { |
| appendU4(m_code, static_cast< sal_uInt32 >(pos2 - pos1)); |
| //FIXME: overflow |
| pos2 += (*i)->m_code.size(); //FIXME: overflow |
| } |
| }} |
| appendStream(m_code, defaultBlock->m_code); |
| {for (std::list< Code * >::const_iterator i(blocks.begin()); |
| i != blocks.end(); ++i) |
| { |
| if (*i != 0) { |
| appendStream(m_code, (*i)->m_code); |
| } |
| }} |
| } |
| |
| void ClassFile::Code::loadIntegerConstant(sal_Int32 value) { |
| if (value >= -1 && value <= 5) { |
| // iconst_<i>: |
| appendU1(m_code, static_cast< sal_uInt8 >(0x02 + value + 1)); |
| } else if (value >= -128 && value <= 127) { |
| // bipush <byte>: |
| appendU1(m_code, 0x10); |
| appendU1(m_code, static_cast< sal_uInt8 >(value)); |
| } else if (value >= -32768 && value <= 32767) { |
| // sipush <byte1> <byte2>: |
| appendU1(m_code, 0x11); |
| appendU2(m_code, static_cast< sal_uInt16 >(value)); |
| } else { |
| ldc(m_classFile.addIntegerInfo(value)); |
| } |
| } |
| |
| void ClassFile::Code::loadStringConstant(rtl::OString const & value) { |
| ldc(m_classFile.addStringInfo(value)); |
| } |
| |
| void ClassFile::Code::loadLocalInteger(sal_uInt16 index) { |
| accessLocal(index, 0x1A, 0x15); // iload_<n>, iload |
| } |
| |
| void ClassFile::Code::loadLocalLong(sal_uInt16 index) { |
| accessLocal(index, 0x1E, 0x16); // load_<n>, load |
| } |
| |
| void ClassFile::Code::loadLocalFloat(sal_uInt16 index) { |
| accessLocal(index, 0x22, 0x17); // load_<n>, load |
| } |
| |
| void ClassFile::Code::loadLocalDouble(sal_uInt16 index) { |
| accessLocal(index, 0x26, 0x18); // load_<n>, load |
| } |
| |
| void ClassFile::Code::loadLocalReference(sal_uInt16 index) { |
| accessLocal(index, 0x2A, 0x19); // aload_<n>, aload |
| } |
| |
| void ClassFile::Code::storeLocalReference(sal_uInt16 index) { |
| accessLocal(index, 0x4B, 0x3A); // astore_<n>, astore |
| } |
| |
| void ClassFile::Code::branchHere(Branch branch) { |
| std::vector< unsigned char >::size_type n = m_code.size(); |
| OSL_ASSERT(n > branch && n - branch <= SAL_MAX_INT16); |
| n -= branch; |
| m_code[branch + 1] = static_cast< sal_uInt8 >(n >> 8); |
| m_code[branch + 2] = static_cast< sal_uInt8 >(n & 0xFF); |
| } |
| |
| void ClassFile::Code::addException( |
| Position start, Position end, Position handler, rtl::OString const & type) |
| { |
| OSL_ASSERT(start < end && end <= m_code.size() && handler <= m_code.size()); |
| if (m_exceptionTableLength == SAL_MAX_UINT16) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Too many exception handlers for Java class file format"))); |
| } |
| ++m_exceptionTableLength; |
| appendU2(m_exceptionTable, static_cast< sal_uInt16 >(start)); |
| //FIXME: overflow |
| appendU2(m_exceptionTable, static_cast< sal_uInt16 >(end)); |
| //FIXME: overflow |
| appendU2(m_exceptionTable, static_cast< sal_uInt16 >(handler)); |
| //FIXME: overflow |
| appendU2(m_exceptionTable, m_classFile.addClassInfo(type)); |
| } |
| |
| ClassFile::Code::Position ClassFile::Code::getPosition() const { |
| return m_code.size(); |
| } |
| |
| ClassFile::Code::Code(ClassFile & classFile): |
| m_classFile(classFile), m_exceptionTableLength(0) |
| {} |
| |
| void ClassFile::Code::ldc(sal_uInt16 index) { |
| if (index <= 0xFF) { |
| // ldc <index>: |
| appendU1(m_code, 0x12); |
| appendU1(m_code, static_cast< sal_uInt8 >(index)); |
| } else { |
| // ldc_w <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0x13); |
| appendU2(m_code, index); |
| } |
| } |
| |
| void ClassFile::Code::accessLocal( |
| sal_uInt16 index, sal_uInt8 fastOp, sal_uInt8 normalOp) |
| { |
| if (index <= 3) { |
| // ...load/store_<n>: |
| appendU1(m_code, static_cast< sal_uInt8 >(fastOp + index)); |
| } else if (index <= 0xFF) { |
| // ...load/store <index>: |
| appendU1(m_code, normalOp); |
| appendU1(m_code, static_cast< sal_uInt8 >(index)); |
| } else { |
| // wide ...load/store <indexbyte1> <indexbyte2>: |
| appendU1(m_code, 0xC4); |
| appendU1(m_code, normalOp); |
| appendU2(m_code, index); |
| } |
| } |
| |
| ClassFile::ClassFile( |
| AccessFlags accessFlags, rtl::OString const & thisClass, |
| rtl::OString const & superClass, rtl::OString const & signature): |
| m_constantPoolCount(1), m_accessFlags(accessFlags), m_interfacesCount(0), |
| m_fieldsCount(0), m_methodsCount(0), m_attributesCount(0) |
| { |
| m_thisClass = addClassInfo(thisClass); |
| m_superClass = addClassInfo(superClass); |
| if ( !signature.isEmpty() ) { |
| ++m_attributesCount; |
| appendU2( |
| m_attributes, |
| addUtf8Info(rtl::OString(RTL_CONSTASCII_STRINGPARAM("Signature")))); |
| appendU4(m_attributes, 2); |
| appendU2(m_attributes, addUtf8Info(signature)); |
| } |
| } |
| |
| ClassFile::~ClassFile() {} |
| |
| ClassFile::Code * ClassFile::newCode() { |
| return new Code(*this); |
| } |
| |
| sal_uInt16 ClassFile::addIntegerInfo(sal_Int32 value) { |
| std::map< sal_Int32, sal_uInt16 >::iterator i(m_integerInfos.find(value)); |
| if (i != m_integerInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 3); |
| appendU4(m_constantPool, static_cast< sal_uInt32 >(value)); |
| if (!m_integerInfos.insert( |
| std::map< sal_Int32, sal_uInt16 >::value_type(value, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addFloatInfo(float value) { |
| std::map< float, sal_uInt16 >::iterator i(m_floatInfos.find(value)); |
| if (i != m_floatInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 4); |
| union { float floatBytes; sal_uInt32 uint32Bytes; } bytes; |
| bytes.floatBytes = value; |
| appendU4(m_constantPool, bytes.uint32Bytes); |
| if (!m_floatInfos.insert( |
| std::map< float, sal_uInt16 >::value_type(value, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addLongInfo(sal_Int64 value) { |
| std::map< sal_Int64, sal_uInt16 >::iterator i(m_longInfos.find(value)); |
| if (i != m_longInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(2); |
| appendU1(m_constantPool, 5); |
| appendU8(m_constantPool, static_cast< sal_uInt64 >(value)); |
| if (!m_longInfos.insert( |
| std::map< sal_Int64, sal_uInt16 >::value_type(value, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addDoubleInfo(double value) { |
| std::map< double, sal_uInt16 >::iterator i(m_doubleInfos.find(value)); |
| if (i != m_doubleInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(2); |
| appendU1(m_constantPool, 6); |
| union { double doubleBytes; sal_uInt64 uint64Bytes; } bytes; |
| bytes.doubleBytes = value; |
| appendU8(m_constantPool, bytes.uint64Bytes); |
| if (!m_doubleInfos.insert( |
| std::map< double, sal_uInt16 >::value_type(value, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| void ClassFile::addInterface(rtl::OString const & interface) { |
| if (m_interfacesCount == SAL_MAX_UINT16) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Too many interfaces for Java class file format"))); |
| } |
| ++m_interfacesCount; |
| appendU2(m_interfaces, addClassInfo(interface)); |
| } |
| |
| void ClassFile::addField( |
| AccessFlags accessFlags, rtl::OString const & name, |
| rtl::OString const & descriptor, sal_uInt16 constantValueIndex, |
| rtl::OString const & signature) |
| { |
| if (m_fieldsCount == SAL_MAX_UINT16) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Too many fields for Java class file format"))); |
| } |
| ++m_fieldsCount; |
| appendU2(m_fields, static_cast< sal_uInt16 >(accessFlags)); |
| appendU2(m_fields, addUtf8Info(name)); |
| appendU2(m_fields, addUtf8Info(descriptor)); |
| appendU2( |
| m_fields, |
| ((constantValueIndex == 0 ? 0 : 1) |
| + (signature.isEmpty() ? 0 : 1))); |
| if (constantValueIndex != 0) { |
| appendU2( |
| m_fields, |
| addUtf8Info( |
| rtl::OString(RTL_CONSTASCII_STRINGPARAM("ConstantValue")))); |
| appendU4(m_fields, 2); |
| appendU2(m_fields, constantValueIndex); |
| } |
| appendSignatureAttribute(m_fields, signature); |
| } |
| |
| void ClassFile::addMethod( |
| AccessFlags accessFlags, rtl::OString const & name, |
| rtl::OString const & descriptor, Code const * code, |
| std::vector< rtl::OString > const & exceptions, |
| rtl::OString const & signature) |
| { |
| if (m_methodsCount == SAL_MAX_UINT16) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Too many methods for Java class file format"))); |
| } |
| ++m_methodsCount; |
| appendU2(m_methods, static_cast< sal_uInt16 >(accessFlags)); |
| appendU2(m_methods, addUtf8Info(name)); |
| appendU2(m_methods, addUtf8Info(descriptor)); |
| std::vector< rtl::OString >::size_type excs = exceptions.size(); |
| if (excs > SAL_MAX_UINT16) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Too many exception specifications for Java class file" |
| " format"))); |
| } |
| appendU2( |
| m_methods, |
| ((code == 0 ? 0 : 1) + (exceptions.empty() ? 0 : 1) |
| + (signature.isEmpty() ? 0 : 1))); |
| if (code != 0) { |
| std::vector< unsigned char >::size_type codeSize = code->m_code.size(); |
| std::vector< unsigned char >::size_type exceptionTableSize |
| = code->m_exceptionTable.size(); |
| if (codeSize > SAL_MAX_UINT32 - (2 + 2 + 4 + 2 + 2) |
| || (exceptionTableSize |
| > (SAL_MAX_UINT32 - (2 + 2 + 4 + 2 + 2) |
| - static_cast< sal_uInt32 >(codeSize)))) |
| { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Code block is too big for Java class file format"))); |
| } |
| appendU2( |
| m_methods, |
| addUtf8Info(rtl::OString(RTL_CONSTASCII_STRINGPARAM("Code")))); |
| appendU4( |
| m_methods, |
| (2 + 2 + 4 + static_cast< sal_uInt32 >(codeSize) + 2 |
| + static_cast< sal_uInt32 >(exceptionTableSize) + 2)); |
| appendU2(m_methods, code->m_maxStack); |
| appendU2(m_methods, code->m_maxLocals); |
| appendU4(m_methods, static_cast< sal_uInt32 >(codeSize)); |
| appendStream(m_methods, code->m_code); |
| appendU2(m_methods, code->m_exceptionTableLength); |
| appendStream(m_methods, code->m_exceptionTable); |
| appendU2(m_methods, 0); |
| } |
| if (!exceptions.empty()) { |
| appendU2( |
| m_methods, |
| addUtf8Info( |
| rtl::OString(RTL_CONSTASCII_STRINGPARAM("Exceptions")))); |
| appendU4( |
| m_methods, |
| static_cast< sal_uInt32 >(2 + 2 * static_cast< sal_uInt32 >(excs))); |
| appendU2(m_methods, static_cast< sal_uInt16 >(excs)); |
| for (std::vector< rtl::OString >::const_iterator i(exceptions.begin()); |
| i != exceptions.end(); ++i) |
| { |
| appendU2(m_methods, addClassInfo(*i)); |
| } |
| } |
| appendSignatureAttribute(m_methods, signature); |
| } |
| |
| #define CLASSFILE_FMT 49.0 // a classfile format understood by JDK 5/6/7 |
| |
| void ClassFile::write(FileStream & file) const { |
| writeU4(file, 0xCAFEBABE); |
| writeU2(file, static_cast<sal_uInt16>((CLASSFILE_FMT-(int)CLASSFILE_FMT)*100000)); |
| writeU2(file, static_cast<sal_uInt16>((int)CLASSFILE_FMT)); |
| writeU2(file, m_constantPoolCount); |
| writeStream(file, m_constantPool); |
| writeU2(file, static_cast< sal_uInt16 >(m_accessFlags)); |
| writeU2(file, m_thisClass); |
| writeU2(file, m_superClass); |
| writeU2(file, m_interfacesCount); |
| writeStream(file, m_interfaces); |
| writeU2(file, m_fieldsCount); |
| writeStream(file, m_fields); |
| writeU2(file, m_methodsCount); |
| writeStream(file, m_methods); |
| writeU2(file, m_attributesCount); |
| writeStream(file, m_attributes); |
| } |
| |
| sal_uInt16 ClassFile::nextConstantPoolIndex(sal_uInt16 width) { |
| OSL_ASSERT(width == 1 || width == 2); |
| if (m_constantPoolCount > SAL_MAX_UINT16 - width) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "Too many constant pool items for Java class file" |
| " format"))); |
| } |
| sal_uInt16 index = m_constantPoolCount; |
| m_constantPoolCount = m_constantPoolCount + width; |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addUtf8Info(rtl::OString const & value) { |
| std::map< rtl::OString, sal_uInt16 >::iterator i(m_utf8Infos.find(value)); |
| if (i != m_utf8Infos.end()) { |
| return i->second; |
| } |
| if (value.getLength() > SAL_MAX_UINT16) { |
| throw CannotDumpException( |
| rtl::OString( |
| RTL_CONSTASCII_STRINGPARAM( |
| "UTF-8 string too long for Java class file format"))); |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 1); |
| appendU2(m_constantPool, static_cast< sal_uInt16 >(value.getLength())); |
| for (sal_Int32 j = 0; j < value.getLength(); ++j) { |
| appendU1(m_constantPool, static_cast< sal_uInt8 >(value[j])); |
| } |
| if (!m_utf8Infos.insert( |
| std::map< rtl::OString, sal_uInt16 >::value_type(value, index)). |
| second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addClassInfo(rtl::OString const & type) { |
| sal_uInt16 nameIndex = addUtf8Info(type); |
| std::map< sal_uInt16, sal_uInt16 >::iterator i( |
| m_classInfos.find(nameIndex)); |
| if (i != m_classInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 7); |
| appendU2(m_constantPool, nameIndex); |
| if (!m_classInfos.insert( |
| std::map< sal_uInt16, sal_uInt16 >::value_type(nameIndex, index)). |
| second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addStringInfo(rtl::OString const & value) { |
| sal_uInt16 stringIndex = addUtf8Info(value); |
| std::map< sal_uInt16, sal_uInt16 >::iterator i( |
| m_stringInfos.find(stringIndex)); |
| if (i != m_stringInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 8); |
| appendU2(m_constantPool, stringIndex); |
| if (!m_stringInfos.insert( |
| std::map< sal_uInt16, sal_uInt16 >::value_type(stringIndex, index)). |
| second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addFieldrefInfo( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| sal_uInt16 classIndex = addClassInfo(type); |
| sal_uInt16 nameAndTypeIndex = addNameAndTypeInfo(name, descriptor); |
| sal_uInt32 key = (static_cast< sal_uInt32 >(classIndex) << 16) |
| | nameAndTypeIndex; |
| std::map< sal_uInt32, sal_uInt16 >::iterator i(m_fieldrefInfos.find(key)); |
| if (i != m_fieldrefInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 9); |
| appendU2(m_constantPool, classIndex); |
| appendU2(m_constantPool, nameAndTypeIndex); |
| if (!m_fieldrefInfos.insert( |
| std::map< sal_uInt32, sal_uInt16 >::value_type(key, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addMethodrefInfo( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| sal_uInt16 classIndex = addClassInfo(type); |
| sal_uInt16 nameAndTypeIndex = addNameAndTypeInfo(name, descriptor); |
| sal_uInt32 key = (static_cast< sal_uInt32 >(classIndex) << 16) |
| | nameAndTypeIndex; |
| std::map< sal_uInt32, sal_uInt16 >::iterator i(m_methodrefInfos.find(key)); |
| if (i != m_methodrefInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 10); |
| appendU2(m_constantPool, classIndex); |
| appendU2(m_constantPool, nameAndTypeIndex); |
| if (!m_methodrefInfos.insert( |
| std::map< sal_uInt32, sal_uInt16 >::value_type(key, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addInterfaceMethodrefInfo( |
| rtl::OString const & type, rtl::OString const & name, |
| rtl::OString const & descriptor) |
| { |
| sal_uInt16 classIndex = addClassInfo(type); |
| sal_uInt16 nameAndTypeIndex = addNameAndTypeInfo(name, descriptor); |
| sal_uInt32 key = (static_cast< sal_uInt32 >(classIndex) << 16) |
| | nameAndTypeIndex; |
| std::map< sal_uInt32, sal_uInt16 >::iterator i( |
| m_interfaceMethodrefInfos.find(key)); |
| if (i != m_interfaceMethodrefInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 11); |
| appendU2(m_constantPool, classIndex); |
| appendU2(m_constantPool, nameAndTypeIndex); |
| if (!m_interfaceMethodrefInfos.insert( |
| std::map< sal_uInt32, sal_uInt16 >::value_type(key, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| sal_uInt16 ClassFile::addNameAndTypeInfo( |
| rtl::OString const & name, rtl::OString const & descriptor) |
| { |
| sal_uInt16 nameIndex = addUtf8Info(name); |
| sal_uInt16 descriptorIndex = addUtf8Info(descriptor); |
| sal_uInt32 key = (static_cast< sal_uInt32 >(nameIndex) << 16) |
| | descriptorIndex; |
| std::map< sal_uInt32, sal_uInt16 >::iterator i( |
| m_nameAndTypeInfos.find(key)); |
| if (i != m_nameAndTypeInfos.end()) { |
| return i->second; |
| } |
| sal_uInt16 index = nextConstantPoolIndex(1); |
| appendU1(m_constantPool, 12); |
| appendU2(m_constantPool, nameIndex); |
| appendU2(m_constantPool, descriptorIndex); |
| if (!m_nameAndTypeInfos.insert( |
| std::map< sal_uInt32, sal_uInt16 >::value_type(key, index)).second) |
| { |
| OSL_ASSERT(false); |
| } |
| return index; |
| } |
| |
| void ClassFile::appendSignatureAttribute( |
| std::vector< unsigned char > & stream, rtl::OString const & signature) |
| { |
| if ( !signature.isEmpty() ) { |
| appendU2( |
| stream, |
| addUtf8Info(rtl::OString(RTL_CONSTASCII_STRINGPARAM("Signature")))); |
| appendU4(stream, 2); |
| appendU2(stream, addUtf8Info(signature)); |
| } |
| } |
