~udienz/blankon/chromium-v8.head

Viewing changes to debian/patches/hidden.patch

Committer: Alexander Sack
Date: 2009-07-16 23:09:57 UTC
Revision ID: asac@ubuntu.com-20090716230957-brewk5ra3vcd2wz1

add experimental GCC visibility patch to make all internal stuff hidden in libv8.so
- adds debian/patches/hidden.patch
- updates debian/patches/series

files added:
debian/patches/hidden.patch

files modified:
debian/patches/series

Show diffs side-by-side

added added

removed removed

debian/patches/hidden.patch

---

include/v8-debug.h | 2 ++

include/v8.h | 2 +-

src/accessors.h | 4 ++++

src/allocation.h | 4 ++++

src/api.h | 4 ++++

src/apiutils.h | 4 ++++

src/arguments.h | 4 ++++

src/arm/assembler-arm-inl.h | 4 ++++

src/arm/assembler-arm.h | 4 ++++

src/arm/codegen-arm-inl.h | 4 ++++

src/arm/codegen-arm.h | 4 ++++

src/arm/constants-arm.h | 4 ++++

src/arm/frames-arm.h | 4 ++++

src/arm/macro-assembler-arm.h | 4 ++++

src/arm/regexp-macro-assembler-arm.h | 4 ++++

src/arm/register-allocator-arm-inl.h | 4 ++++

src/arm/register-allocator-arm.h | 4 ++++

src/arm/simulator-arm.h | 4 ++++

src/arm/virtual-frame-arm.h | 4 ++++

src/assembler.h | 4 ++++

src/ast.cc | 3 +++

src/ast.h | 4 ++++

src/bootstrapper.h | 4 ++++

src/builtins.h | 4 ++++

src/bytecodes-irregexp.h | 2 ++

src/char-predicates-inl.h | 4 ++++

src/char-predicates.h | 4 ++++

src/checks.h | 4 ++++

src/code-stubs.h | 4 ++++

src/code.h | 4 ++++

src/codegen-inl.h | 4 ++++

src/codegen.h | 4 ++++

src/compilation-cache.cc | 3 +++

src/compilation-cache.h | 4 ++++

src/compiler.h | 4 ++++

src/contexts.h | 4 ++++

src/conversions-inl.h | 4 ++++

src/conversions.h | 4 ++++

src/counters.h | 4 ++++

src/cpu.h | 4 ++++

src/d8-debug.h | 4 ++++

src/d8.h | 4 ++++

src/dateparser-inl.h | 4 ++++

src/dateparser.h | 4 ++++

src/debug-agent.h | 4 ++++

src/debug.h | 4 ++++

src/disasm.h | 4 ++++

src/disassembler.h | 4 ++++

src/execution.h | 4 ++++

src/factory.h | 4 ++++

src/flags.h | 4 ++++

src/frame-element.h | 4 ++++

src/frames-inl.h | 4 ++++

src/frames.h | 4 ++++

src/func-name-inferrer.h | 4 ++++

src/global-handles.h | 4 ++++

src/globals.h | 4 ++++

src/handles-inl.h | 4 ++++

src/handles.h | 4 ++++

src/hashmap.h | 4 ++++

src/heap-inl.h | 4 ++++

src/heap.h | 4 ++++

src/ia32/assembler-ia32-inl.h | 4 ++++

src/ia32/assembler-ia32.h | 4 ++++

src/ia32/codegen-ia32-inl.h | 4 ++++

src/ia32/codegen-ia32.h | 4 ++++

src/ia32/disasm-ia32.cc | 2 ++

src/ia32/frames-ia32.h | 4 ++++

src/ia32/macro-assembler-ia32.h | 4 ++++

src/ia32/regexp-macro-assembler-ia32.h | 4 ++++

src/ia32/register-allocator-ia32-inl.h | 4 ++++

src/ia32/register-allocator-ia32.h | 4 ++++

src/ia32/virtual-frame-ia32.h | 4 ++++

src/ic-inl.h | 4 ++++

src/ic.h | 4 ++++

src/interpreter-irregexp.h | 4 ++++

src/jsregexp-inl.h | 4 ++++

src/jsregexp.cc | 3 +++

src/jsregexp.h | 4 ++++

src/jump-target-inl.h | 4 ++++

src/jump-target.h | 4 ++++

src/list-inl.h | 4 ++++

src/list.h | 4 ++++

src/log-inl.h | 4 ++++

src/log-utils.h | 4 ++++

src/log.cc | 3 +++

src/log.h | 4 ++++

src/mark-compact.h | 4 ++++

src/memory.h | 4 ++++

src/messages.h | 4 ++++

src/natives.h | 4 ++++

src/objects-inl.h | 4 ++++

src/objects.h | 4 ++++

src/oprofile-agent.h | 4 ++++

src/parser.cc | 3 +++

src/parser.h | 4 ++++

src/platform-linux.cc | 3 +++

src/platform-posix.cc | 3 +++

100

src/platform.h | 4 ++++

101

src/prettyprinter.h | 4 ++++

102

src/property.h | 4 ++++

103

src/regexp-macro-assembler-irregexp-inl.h | 4 ++++

104

src/regexp-macro-assembler-irregexp.h | 4 ++++

105

src/regexp-macro-assembler-tracer.h | 4 ++++

106

src/regexp-macro-assembler.h | 4 ++++

107

src/regexp-stack.h | 4 ++++

108

src/register-allocator-inl.h | 4 ++++

109

src/register-allocator.h | 4 ++++

110

src/rewriter.cc | 4 ++++

111

src/rewriter.h | 4 ++++

112

src/runtime.h | 4 ++++

113

src/scanner.h | 4 ++++

114

src/scopeinfo.h | 4 ++++

115

src/scopes.cc | 3 +++

116

src/scopes.h | 4 ++++

117

src/serialize.h | 4 ++++

118

src/shell.h | 4 ++++

119

src/smart-pointer.h | 4 ++++

120

src/snapshot.h | 4 ++++

121

src/spaces-inl.h | 4 ++++

122

src/spaces.h | 4 ++++

123

src/string-stream.h | 4 ++++

124

src/stub-cache.h | 4 ++++

125

src/token.h | 4 ++++

126

src/top.h | 4 ++++

127

src/unicode-inl.h | 4 ++++

128

src/unicode.h | 4 ++++

129

src/usage-analyzer.cc | 3 +++

130

src/usage-analyzer.h | 4 ++++

131

src/utils.h | 4 ++++

132

src/v8-counters.h | 4 ++++

133

src/v8.h | 4 ++++

134

src/v8threads.h | 4 ++++

135

src/variables.h | 4 ++++

136

src/version.h | 4 ++++

137

src/x64/assembler-x64-inl.h | 4 ++++

138

src/x64/assembler-x64.h | 4 ++++

139

src/x64/codegen-x64-inl.h | 4 ++++

140

src/x64/codegen-x64.h | 4 ++++

141

src/x64/frames-x64.h | 4 ++++

142

src/x64/macro-assembler-x64.h | 4 ++++

143

src/x64/register-allocator-x64-inl.h | 4 ++++

144

src/x64/register-allocator-x64.h | 4 ++++

145

src/x64/simulator-x64.h | 2 ++

146

src/x64/virtual-frame-x64.h | 4 ++++

147

src/zone-inl.h | 4 ++++

148

src/zone.h | 4 ++++

149

147 files changed, 568 insertions(+), 1 deletion(-)

150

151

Index: chromium-v8-1.2.14~svn20090716r2483/include/v8-debug.h

152

===================================================================

153

--- chromium-v8-1.2.14~svn20090716r2483.orig/include/v8-debug.h

154

+++ chromium-v8-1.2.14~svn20090716r2483/include/v8-debug.h

155

@@ -62,16 +62,18 @@

156

#endif // defined(__GNUC__) && (__GNUC__ >= 4)

157

158

#endif // _WIN32

159

160

161

/**

162

* Debugger support for the V8 JavaScript engine.

163

164

+#pragma GCC visibility push(hidden)

165

166

namespace v8 {

167

168

// Debug events which can occur in the V8 JavaScript engine.

169

enum DebugEvent {

170

Break = 1,

171

Exception = 2,

172

NewFunction = 3,

173

BeforeCompile = 4,

174

Index: chromium-v8-1.2.14~svn20090716r2483/include/v8.h

175

===================================================================

176

--- chromium-v8-1.2.14~svn20090716r2483.orig/include/v8.h

177

+++ chromium-v8-1.2.14~svn20090716r2483/include/v8.h

178

@@ -169,16 +169,17 @@

179

* longer used.

180

181

* It is safe to extract the object stored in the handle by

182

* dereferencing the handle (for instance, to extract the Object* from

183

* an Handle<Object>); the value will still be governed by a handle

184

* behind the scenes and the same rules apply to these values as to

185

* their handles.

186

187

188

template <class T> class V8EXPORT_INLINE Handle {

189

public:

190

191

/**

192

* Creates an empty handle.

193

194

Handle();

195

196

@@ -2606,15 +2607,14 @@

197

198

/**

199

* \example process.cc

200

201

202

203

} // namespace v8

204

205

206

#undef V8EXPORT

207

#undef V8EXPORT_INLINE

208

#undef TYPE_CHECK

209

210

211

#endif // V8_H_

212

Index: chromium-v8-1.2.14~svn20090716r2483/src/accessors.h

213

===================================================================

214

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/accessors.h

215

+++ chromium-v8-1.2.14~svn20090716r2483/src/accessors.h

216

@@ -23,16 +23,18 @@

217

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

218

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

219

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

220

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

221

222

#ifndef V8_ACCESSORS_H_

223

#define V8_ACCESSORS_H_

224

225

+#pragma GCC visibility push(hidden)

226

227

namespace v8 {

228

namespace internal {

229

230

// The list of accessor descriptors. This is a second-order macro

231

// taking a macro to be applied to all accessor descriptor names.

232

#define ACCESSOR_DESCRIPTOR_LIST(V) \

233

V(FunctionPrototype) \

234

V(FunctionLength) \

235

@@ -104,9 +106,11 @@

236

static Object* FlattenNumber(Object* value);

237

static Object* IllegalSetter(JSObject*, Object*, void*);

238

static Object* IllegalGetAccessor(Object* object, void*);

239

static Object* ReadOnlySetAccessor(JSObject*, Object* value, void*);

240

};

241

242

} } // namespace v8::internal

243

244

+#pragma GCC visibility pop

245

246

#endif // V8_ACCESSORS_H_

247

Index: chromium-v8-1.2.14~svn20090716r2483/src/allocation.h

248

===================================================================

249

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/allocation.h

250

+++ chromium-v8-1.2.14~svn20090716r2483/src/allocation.h

251

@@ -23,16 +23,18 @@

252

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

253

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

254

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

255

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

256

257

#ifndef V8_ALLOCATION_H_

258

#define V8_ALLOCATION_H_

259

260

+#pragma GCC visibility push(hidden)

261

262

namespace v8 {

263

namespace internal {

264

265

266

// A class that controls whether allocation is allowed. This is for

267

// the C++ heap only!

268

class NativeAllocationChecker {

269

public:

270

@@ -161,9 +163,11 @@

271

void LinkTo(PreallocatedStorage* other);

272

void Unlink();

273

DISALLOW_IMPLICIT_CONSTRUCTORS(PreallocatedStorage);

274

};

275

276

277

} } // namespace v8::internal

278

279

+#pragma GCC visibility pop

280

281

#endif // V8_ALLOCATION_H_

282

Index: chromium-v8-1.2.14~svn20090716r2483/src/api.h

283

===================================================================

284

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/api.h

285

+++ chromium-v8-1.2.14~svn20090716r2483/src/api.h

286

@@ -26,16 +26,18 @@

287

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

288

289

#ifndef V8_API_H_

290

#define V8_API_H_

291

292

#include "apiutils.h"

293

#include "factory.h"

294

295

+#pragma GCC visibility push(hidden)

296

297

namespace v8 {

298

299

// Constants used in the implementation of the API. The most natural thing

300

// would usually be to place these with the classes that use them, but

301

// we want to keep them out of v8.h because it is an externally

302

// visible file.

303

class Consts {

304

public:

305

@@ -447,9 +449,11 @@

306

v8::ImplementationUtilities::ZapHandleRange(

307

reinterpret_cast<void**>(spare),

308

reinterpret_cast<void**>(&spare[kHandleBlockSize]));

309

#endif

310

}

311

312

} } // namespace v8::internal

313

314

+#pragma GCC visibility pop

315

316

#endif // V8_API_H_

317

Index: chromium-v8-1.2.14~svn20090716r2483/src/apiutils.h

318

===================================================================

319

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/apiutils.h

320

+++ chromium-v8-1.2.14~svn20090716r2483/src/apiutils.h

321

@@ -23,16 +23,18 @@

322

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

323

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

324

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

325

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

326

327

#ifndef V8_APIUTILS_H_

328

#define V8_APIUTILS_H_

329

330

+#pragma GCC visibility push(hidden)

331

332

namespace v8 {

333

334

class ImplementationUtilities {

335

public:

336

static v8::Handle<v8::Primitive> Undefined();

337

static v8::Handle<v8::Primitive> Null();

338

static v8::Handle<v8::Boolean> True();

339

static v8::Handle<v8::Boolean> False();

340

@@ -61,9 +63,11 @@

341

342

#ifdef DEBUG

343

static void ZapHandleRange(void** begin, void** end);

344

#endif

345

};

346

347

} // namespace v8

348

349

+#pragma GCC visibility pop

350

351

#endif // V8_APIUTILS_H_

352

Index: chromium-v8-1.2.14~svn20090716r2483/src/arguments.h

353

===================================================================

354

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arguments.h

355

+++ chromium-v8-1.2.14~svn20090716r2483/src/arguments.h

356

@@ -23,16 +23,18 @@

357

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

358

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

359

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

360

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

361

362

#ifndef V8_ARGUMENTS_H_

363

#define V8_ARGUMENTS_H_

364

365

+#pragma GCC visibility push(hidden)

366

367

namespace v8 {

368

namespace internal {

369

370

// Arguments provides access to runtime call parameters.

371

372

// It uses the fact that the instance fields of Arguments

373

// (length_, arguments_) are "overlayed" with the parameters

374

// (no. of parameters, and the parameter pointer) passed so

375

@@ -63,9 +65,11 @@

376

377

private:

378

int length_;

379

Object** arguments_;

380

};

381

382

} } // namespace v8::internal

383

384

+#pragma GCC visibility pop

385

386

#endif // V8_ARGUMENTS_H_

387

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/assembler-arm.h

388

===================================================================

389

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/assembler-arm.h

390

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/assembler-arm.h

391

@@ -37,16 +37,18 @@

392

// A light-weight ARM Assembler

393

// Generates user mode instructions for the ARM architecture up to version 5

394

395

#ifndef V8_ARM_ASSEMBLER_ARM_H_

396

#define V8_ARM_ASSEMBLER_ARM_H_

397

398

#include "assembler.h"

399

400

+#pragma GCC visibility push(hidden)

401

402

namespace v8 {

403

namespace internal {

404

405

// CPU Registers.

406

407

// 1) We would prefer to use an enum, but enum values are assignment-

408

// compatible with int, which has caused code-generation bugs.

409

410

@@ -780,9 +782,11 @@

411

void next(Label* L);

412

413

// Record reloc info for current pc_

414

void RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data = 0);

415

};

416

417

} } // namespace v8::internal

418

419

+#pragma GCC visibility pop

420

421

#endif // V8_ARM_ASSEMBLER_ARM_H_

422

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/assembler-arm-inl.h

423

===================================================================

424

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/assembler-arm-inl.h

425

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/assembler-arm-inl.h

426

@@ -36,16 +36,18 @@

427

428

#ifndef V8_ARM_ASSEMBLER_ARM_INL_H_

429

#define V8_ARM_ASSEMBLER_ARM_INL_H_

430

431

#include "arm/assembler-arm.h"

432

#include "cpu.h"

433

434

435

+#pragma GCC visibility push(hidden)

436

437

namespace v8 {

438

namespace internal {

439

440

Condition NegateCondition(Condition cc) {

441

ASSERT(cc != al);

442

return static_cast<Condition>(cc ^ ne);

443

}

444

445

@@ -242,9 +244,11 @@

446

// However, on ARM, no instruction was actually patched by the assignment

447

// above; the target address is not part of an instruction, it is patched in

448

// the constant pool and is read via a data access; the instruction accessing

449

// this address in the constant pool remains unchanged.

450

}

451

452

} } // namespace v8::internal

453

454

+#pragma GCC visibility pop

455

456

#endif // V8_ARM_ASSEMBLER_ARM_INL_H_

457

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/codegen-arm.h

458

===================================================================

459

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/codegen-arm.h

460

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/codegen-arm.h

461

@@ -23,16 +23,18 @@

462

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

463

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

464

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

465

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

466

467

#ifndef V8_ARM_CODEGEN_ARM_H_

468

#define V8_ARM_CODEGEN_ARM_H_

469

470

+#pragma GCC visibility push(hidden)

471

472

namespace v8 {

473

namespace internal {

474

475

// Forward declarations

476

class DeferredCode;

477

class RegisterAllocator;

478

class RegisterFile;

479

480

@@ -418,9 +420,11 @@

481

friend class Reference;

482

483

DISALLOW_COPY_AND_ASSIGN(CodeGenerator);

484

};

485

486

487

} } // namespace v8::internal

488

489

+#pragma GCC visibility pop

490

491

#endif // V8_ARM_CODEGEN_ARM_H_

492

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/codegen-arm-inl.h

493

===================================================================

494

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/codegen-arm-inl.h

495

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/codegen-arm-inl.h

496

@@ -24,16 +24,18 @@

497

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

498

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

499

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

500

501

502

#ifndef V8_ARM_CODEGEN_ARM_INL_H_

503

#define V8_ARM_CODEGEN_ARM_INL_H_

504

505

+#pragma GCC visibility push(hidden)

506

507

namespace v8 {

508

namespace internal {

509

510

#define __ ACCESS_MASM(masm_)

511

512

// Platform-specific inline functions.

513

514

void DeferredCode::Jump() { __ jmp(&entry_label_); }

515

@@ -48,9 +50,11 @@

516

GenerateFastMathOp(COS, args);

517

}

518

519

520

#undef __

521

522

} } // namespace v8::internal

523

524

+#pragma GCC visibility pop

525

526

#endif // V8_ARM_CODEGEN_ARM_INL_H_

527

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/constants-arm.h

528

===================================================================

529

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/constants-arm.h

530

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/constants-arm.h

531

@@ -44,16 +44,18 @@

532

#endif

533

534

// Simulator should support ARM5 instructions.

535

#if !defined(__arm__)

536

# define __ARM_ARCH_5__ 1

537

# define __ARM_ARCH_5T__ 1

538

#endif

539

540

+#pragma GCC visibility push(hidden)

541

542

namespace assembler {

543

namespace arm {

544

545

// Defines constants and accessor classes to assemble, disassemble and

546

// simulate ARM instructions.

547

548

// Section references in the code refer to the "ARM Architecture Reference

549

// Manual" from July 2005 (available at http://www.arm.com/miscPDFs/14128.pdf)

550

@@ -266,9 +268,11 @@

551

private:

552

// We need to prevent the creation of instances of class Instr.

553

DISALLOW_IMPLICIT_CONSTRUCTORS(Instr);

554

};

555

556

557

} } // namespace assembler::arm

558

559

+#pragma GCC visibility pop

560

561

#endif // V8_ARM_CONSTANTS_ARM_H_

562

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/frames-arm.h

563

===================================================================

564

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/frames-arm.h

565

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/frames-arm.h

566

@@ -23,16 +23,18 @@

567

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

568

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

569

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

570

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

571

572

#ifndef V8_ARM_FRAMES_ARM_H_

573

#define V8_ARM_FRAMES_ARM_H_

574

575

+#pragma GCC visibility push(hidden)

576

577

namespace v8 {

578

namespace internal {

579

580

581

// The ARM ABI does not specify the usage of register r9, which may be reserved

582

// as the static base or thread register on some platforms, in which case we

583

// leave it alone. Adjust the value of kR9Available accordingly:

584

static const int kR9Available = 1; // 1 if available to us, 0 if reserved

585

@@ -154,9 +156,11 @@

586

inline Object* JavaScriptFrame::function_slot_object() const {

587

const int offset = JavaScriptFrameConstants::kFunctionOffset;

588

return Memory::Object_at(fp() + offset);

589

}

590

591

592

} } // namespace v8::internal

593

594

+#pragma GCC visibility pop

595

596

#endif // V8_ARM_FRAMES_ARM_H_

597

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/macro-assembler-arm.h

598

===================================================================

599

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/macro-assembler-arm.h

600

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/macro-assembler-arm.h

601

@@ -25,16 +25,18 @@

602

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

603

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

604

605

#ifndef V8_ARM_MACRO_ASSEMBLER_ARM_H_

606

#define V8_ARM_MACRO_ASSEMBLER_ARM_H_

607

608

#include "assembler.h"

609

610

+#pragma GCC visibility push(hidden)

611

612

namespace v8 {

613

namespace internal {

614

615

616

// Give alias names to registers

617

const Register cp = { 8 }; // JavaScript context pointer

618

619

620

@@ -337,9 +339,11 @@

621

#define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->

622

#else

623

#define ACCESS_MASM(masm) masm->

624

#endif

625

626

627

} } // namespace v8::internal

628

629

+#pragma GCC visibility pop

630

631

#endif // V8_ARM_MACRO_ASSEMBLER_ARM_H_

632

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/regexp-macro-assembler-arm.h

633

===================================================================

634

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/regexp-macro-assembler-arm.h

635

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/regexp-macro-assembler-arm.h

636

@@ -23,20 +23,24 @@

637

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

638

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

639

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

640

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

641

642

#ifndef V8_ARM_REGEXP_MACRO_ASSEMBLER_ARM_H_

643

#define V8_ARM_REGEXP_MACRO_ASSEMBLER_ARM_H_

644

645

+#pragma GCC visibility push(hidden)

646

647

namespace v8 {

648

namespace internal {

649

650

class RegExpMacroAssemblerARM: public RegExpMacroAssembler {

651

public:

652

RegExpMacroAssemblerARM();

653

virtual ~RegExpMacroAssemblerARM();

654

};

655

656

}} // namespace v8::internal

657

658

+#pragma GCC visibility pop

659

660

#endif // V8_ARM_REGEXP_MACRO_ASSEMBLER_ARM_H_

661

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/register-allocator-arm.h

662

===================================================================

663

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/register-allocator-arm.h

664

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/register-allocator-arm.h

665

@@ -23,21 +23,25 @@

666

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

667

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

668

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

669

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

670

671

#ifndef V8_ARM_REGISTER_ALLOCATOR_ARM_H_

672

#define V8_ARM_REGISTER_ALLOCATOR_ARM_H_

673

674

+#pragma GCC visibility push(hidden)

675

676

namespace v8 {

677

namespace internal {

678

679

class RegisterAllocatorConstants : public AllStatic {

680

public:

681

static const int kNumRegisters = 12;

682

static const int kInvalidRegister = -1;

683

};

684

685

686

} } // namespace v8::internal

687

688

+#pragma GCC visibility pop

689

690

#endif // V8_ARM_REGISTER_ALLOCATOR_ARM_H_

691

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/register-allocator-arm-inl.h

692

===================================================================

693

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/register-allocator-arm-inl.h

694

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/register-allocator-arm-inl.h

695

@@ -25,16 +25,18 @@

696

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

697

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

698

699

#ifndef V8_ARM_REGISTER_ALLOCATOR_ARM_INL_H_

700

#define V8_ARM_REGISTER_ALLOCATOR_ARM_INL_H_

701

702

#include "v8.h"

703

704

+#pragma GCC visibility push(hidden)

705

706

namespace v8 {

707

namespace internal {

708

709

// -------------------------------------------------------------------------

710

// RegisterAllocator implementation.

711

712

bool RegisterAllocator::IsReserved(Register reg) {

713

return reg.is(cp) || reg.is(fp) || reg.is(sp) || reg.is(pc);

714

@@ -95,9 +97,11 @@

715

// The non-reserved r1 and lr registers are live on JS function entry.

716

Use(r1); // JS function.

717

Use(lr); // Return address.

718

}

719

720

721

} } // namespace v8::internal

722

723

+#pragma GCC visibility pop

724

725

#endif // V8_ARM_REGISTER_ALLOCATOR_ARM_INL_H_

726

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/simulator-arm.h

727

===================================================================

728

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/simulator-arm.h

729

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/simulator-arm.h

730

@@ -61,16 +61,18 @@

731

// the C-based native code.

732

#define GENERATED_CODE_STACK_LIMIT(limit) \

733

(assembler::arm::Simulator::current()->StackLimit())

734

735

736

#include "constants-arm.h"

737

738

739

+#pragma GCC visibility push(hidden)

740

741

namespace assembler {

742

namespace arm {

743

744

class Simulator {

745

public:

746

friend class Debugger;

747

748

enum Register {

749

@@ -205,9 +207,11 @@

750

Instr* break_pc_;

751

instr_t break_instr_;

752

};

753

754

} } // namespace assembler::arm

755

756

#endif // defined(__arm__)

757

758

+#pragma GCC visibility pop

759

760

#endif // V8_ARM_SIMULATOR_ARM_H_

761

Index: chromium-v8-1.2.14~svn20090716r2483/src/arm/virtual-frame-arm.h

762

===================================================================

763

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/arm/virtual-frame-arm.h

764

+++ chromium-v8-1.2.14~svn20090716r2483/src/arm/virtual-frame-arm.h

765

@@ -26,16 +26,18 @@

766

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

767

768

#ifndef V8_ARM_VIRTUAL_FRAME_ARM_H_

769

#define V8_ARM_VIRTUAL_FRAME_ARM_H_

770

771

#include "register-allocator.h"

772

#include "scopes.h"

773

774

+#pragma GCC visibility push(hidden)

775

776

namespace v8 {

777

namespace internal {

778

779

// -------------------------------------------------------------------------

780

// Virtual frames

781

782

// The virtual frame is an abstraction of the physical stack frame. It

783

// encapsulates the parameters, frame-allocated locals, and the expression

784

@@ -528,9 +530,11 @@

785

// Classes that need raw access to the elements_ array.

786

friend class DeferredCode;

787

friend class JumpTarget;

788

};

789

790

791

} } // namespace v8::internal

792

793

+#pragma GCC visibility pop

794

795

#endif // V8_ARM_VIRTUAL_FRAME_ARM_H_

796

Index: chromium-v8-1.2.14~svn20090716r2483/src/assembler.h

797

===================================================================

798

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/assembler.h

799

+++ chromium-v8-1.2.14~svn20090716r2483/src/assembler.h

800

@@ -35,16 +35,18 @@

801

#ifndef V8_ASSEMBLER_H_

802

#define V8_ASSEMBLER_H_

803

804

#include "runtime.h"

805

#include "top.h"

806

#include "zone-inl.h"

807

#include "token.h"

808

809

+#pragma GCC visibility push(hidden)

810

811

namespace v8 {

812

namespace internal {

813

814

815

// -----------------------------------------------------------------------------

816

// Labels represent pc locations; they are typically jump or call targets.

817

// After declaration, a label can be freely used to denote known or (yet)

818

// unknown pc location. Assembler::bind() is used to bind a label to the

819

@@ -473,9 +475,11 @@

820

static inline bool is_uint6(int x) { return is_uintn(x, 6); }

821

static inline bool is_uint8(int x) { return is_uintn(x, 8); }

822

static inline bool is_uint12(int x) { return is_uintn(x, 12); }

823

static inline bool is_uint16(int x) { return is_uintn(x, 16); }

824

static inline bool is_uint24(int x) { return is_uintn(x, 24); }

825

826

} } // namespace v8::internal

827

828

+#pragma GCC visibility pop

829

830

#endif // V8_ASSEMBLER_H_

831

Index: chromium-v8-1.2.14~svn20090716r2483/src/ast.cc

832

===================================================================

833

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ast.cc

834

+++ chromium-v8-1.2.14~svn20090716r2483/src/ast.cc

835

@@ -26,16 +26,17 @@

836

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

837

838

#include "v8.h"

839

840

#include "ast.h"

841

#include "scopes.h"

842

#include "string-stream.h"

843

844

+#pragma GCC visibility push(hidden)

845

namespace v8 {

846

namespace internal {

847

848

849

VariableProxySentinel VariableProxySentinel::this_proxy_(true);

850

VariableProxySentinel VariableProxySentinel::identifier_proxy_(false);

851

ValidLeftHandSideSentinel ValidLeftHandSideSentinel::instance_;

852

Property Property::this_property_(VariableProxySentinel::this_proxy(), NULL, 0);

853

@@ -505,8 +506,10 @@

854

} else {

855

max_match_ += node->max_match();

856

}

857

}

858

}

859

860

861

} } // namespace v8::internal

862

863

+#pragma GCC visibility pop

864

Index: chromium-v8-1.2.14~svn20090716r2483/src/ast.h

865

===================================================================

866

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ast.h

867

+++ chromium-v8-1.2.14~svn20090716r2483/src/ast.h

868

@@ -32,16 +32,18 @@

869

#include "factory.h"

870

#include "runtime.h"

871

#include "token.h"

872

#include "variables.h"

873

#include "macro-assembler.h"

874

#include "jsregexp.h"

875

#include "jump-target.h"

876

877

+#pragma GCC visibility push(hidden)

878

879

namespace v8 {

880

namespace internal {

881

882

// The abstract syntax tree is an intermediate, light-weight

883

// representation of the parsed JavaScript code suitable for

884

// compilation to native code.

885

886

// Nodes are allocated in a separate zone, which allows faster

887

@@ -1707,9 +1709,11 @@

888

889

private:

890

bool stack_overflow_;

891

};

892

893

894

} } // namespace v8::internal

895

896

+#pragma GCC visibility pop

897

898

#endif // V8_AST_H_

899

Index: chromium-v8-1.2.14~svn20090716r2483/src/bootstrapper.h

900

===================================================================

901

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/bootstrapper.h

902

+++ chromium-v8-1.2.14~svn20090716r2483/src/bootstrapper.h

903

@@ -24,16 +24,18 @@

904

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

905

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

906

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

907

908

909

#ifndef V8_BOOTSTRAPPER_H_

910

#define V8_BOOTSTRAPPER_H_

911

912

+#pragma GCC visibility push(hidden)

913

914

namespace v8 {

915

namespace internal {

916

917

// The Boostrapper is the public interface for creating a JavaScript global

918

// context.

919

class Bootstrapper : public AllStatic {

920

public:

921

// Requires: Heap::Setup has been called.

922

@@ -73,9 +75,11 @@

923

// Support for thread preemption.

924

static int ArchiveSpacePerThread();

925

static char* ArchiveState(char* to);

926

static char* RestoreState(char* from);

927

};

928

929

}} // namespace v8::internal

930

931

+#pragma GCC visibility pop

932

933

#endif // V8_BOOTSTRAPPER_H_

934

Index: chromium-v8-1.2.14~svn20090716r2483/src/builtins.h

935

===================================================================

936

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/builtins.h

937

+++ chromium-v8-1.2.14~svn20090716r2483/src/builtins.h

938

@@ -23,16 +23,18 @@

939

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

940

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

941

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

942

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

943

944

#ifndef V8_BUILTINS_H_

945

#define V8_BUILTINS_H_

946

947

+#pragma GCC visibility push(hidden)

948

949

namespace v8 {

950

namespace internal {

951

952

// Define list of builtins implemented in C.

953

#define BUILTIN_LIST_C(V) \

954

V(Illegal) \

955

956

V(EmptyFunction) \

957

@@ -217,9 +219,11 @@

958

static void Generate_ArgumentsAdaptorTrampoline(MacroAssembler* masm);

959

960

static void Generate_FunctionCall(MacroAssembler* masm);

961

static void Generate_FunctionApply(MacroAssembler* masm);

962

};

963

964

} } // namespace v8::internal

965

966

+#pragma GCC visibility pop

967

968

#endif // V8_BUILTINS_H_

969

Index: chromium-v8-1.2.14~svn20090716r2483/src/bytecodes-irregexp.h

970

===================================================================

971

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/bytecodes-irregexp.h

972

+++ chromium-v8-1.2.14~svn20090716r2483/src/bytecodes-irregexp.h

973

@@ -24,16 +24,18 @@

974

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

975

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

976

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

977

978

979

#ifndef V8_BYTECODES_IRREGEXP_H_

980

#define V8_BYTECODES_IRREGEXP_H_

981

982

+#pragma GCC visibility push(hidden)

983

984

namespace v8 {

985

namespace internal {

986

987

988

static const int BYTECODE_MASK = 0xff;

989

// The first argument is packed in with the byte code in one word, but so it

990

// has 24 bits, but it can be positive and negative so only use 23 bits for

991

// positive values.

992

Index: chromium-v8-1.2.14~svn20090716r2483/src/char-predicates.h

993

===================================================================

994

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/char-predicates.h

995

+++ chromium-v8-1.2.14~svn20090716r2483/src/char-predicates.h

996

@@ -23,16 +23,18 @@

997

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

998

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

999

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1000

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1001

1002

#ifndef V8_CHAR_PREDICATES_H_

1003

#define V8_CHAR_PREDICATES_H_

1004

1005

+#pragma GCC visibility push(hidden)

1006

1007

namespace v8 {

1008

namespace internal {

1009

1010

// Unicode character predicates as defined by ECMA-262, 3rd,

1011

// used for lexical analysis.

1012

1013

inline bool IsCarriageReturn(uc32 c);

1014

inline bool IsLineFeed(uc32 c);

1015

@@ -57,9 +59,11 @@

1016

|| unibrow::Number::Is(c)

1017

|| unibrow::CombiningMark::Is(c)

1018

|| unibrow::ConnectorPunctuation::Is(c);

1019

}

1020

};

1021

1022

} } // namespace v8::internal

1023

1024

+#pragma GCC visibility pop

1025

1026

#endif // V8_CHAR_PREDICATES_H_

1027

Index: chromium-v8-1.2.14~svn20090716r2483/src/char-predicates-inl.h

1028

===================================================================

1029

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/char-predicates-inl.h

1030

+++ chromium-v8-1.2.14~svn20090716r2483/src/char-predicates-inl.h

1031

@@ -25,16 +25,18 @@

1032

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1033

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1034

1035

#ifndef V8_CHAR_PREDICATES_INL_H_

1036

#define V8_CHAR_PREDICATES_INL_H_

1037

1038

#include "char-predicates.h"

1039

1040

+#pragma GCC visibility push(hidden)

1041

1042

namespace v8 {

1043

namespace internal {

1044

1045

1046

inline bool IsCarriageReturn(uc32 c) {

1047

return c == 0x000D;

1048

}

1049

1050

@@ -78,9 +80,11 @@

1051

default:

1052

return true;

1053

}

1054

}

1055

1056

1057

} } // namespace v8::internal

1058

1059

+#pragma GCC visibility pop

1060

1061

#endif // V8_CHAR_PREDICATES_INL_H_

1062

Index: chromium-v8-1.2.14~svn20090716r2483/src/checks.h

1063

===================================================================

1064

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/checks.h

1065

+++ chromium-v8-1.2.14~svn20090716r2483/src/checks.h

1066

@@ -174,16 +174,18 @@

1067

"CHECK_EQ(%s, %s) failed\n# Expected: %f\n# Found: %f",

1068

expected_source, value_source, *exp, *val);

1069

}

1070

delete[] exp;

1071

delete[] val;

1072

}

1073

1074

1075

+#pragma GCC visibility push(hidden)

1076

1077

namespace v8 {

1078

class Value;

1079

template <class T> class Handle;

1080

}

1081

1082

1083

void CheckNonEqualsHelper(const char* file,

1084

int line,

1085

@@ -255,9 +257,11 @@

1086

1087

#define ASSERT_TAG_ALIGNED(address) \

1088

ASSERT((reinterpret_cast<intptr_t>(address) & kHeapObjectTagMask) == 0)

1089

1090

#define ASSERT_SIZE_TAG_ALIGNED(size) ASSERT((size & kHeapObjectTagMask) == 0)

1091

1092

#define ASSERT_NOT_NULL(p) ASSERT_NE(NULL, p)

1093

1094

+#pragma GCC visibility pop

1095

1096

#endif // V8_CHECKS_H_

1097

Index: chromium-v8-1.2.14~svn20090716r2483/src/codegen.h

1098

===================================================================

1099

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/codegen.h

1100

+++ chromium-v8-1.2.14~svn20090716r2483/src/codegen.h

1101

@@ -78,16 +78,18 @@

1102

#elif V8_TARGET_ARCH_ARM

1103

#include "arm/codegen-arm.h"

1104

#else

1105

#error Unsupported target architecture.

1106

#endif

1107

1108

#include "register-allocator.h"

1109

1110

+#pragma GCC visibility push(hidden)

1111

1112

namespace v8 {

1113

namespace internal {

1114

1115

1116

// Code generation can be nested. Code generation scopes form a stack

1117

// of active code generators.

1118

class CodeGeneratorScope BASE_EMBEDDED {

1119

public:

1120

@@ -378,9 +380,11 @@

1121

}

1122

#endif

1123

};

1124

1125

1126

} // namespace internal

1127

} // namespace v8

1128

1129

+#pragma GCC visibility pop

1130

1131

#endif // V8_CODEGEN_H_

1132

Index: chromium-v8-1.2.14~svn20090716r2483/src/codegen-inl.h

1133

===================================================================

1134

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/codegen-inl.h

1135

+++ chromium-v8-1.2.14~svn20090716r2483/src/codegen-inl.h

1136

@@ -38,16 +38,18 @@

1137

#include "x64/codegen-x64-inl.h"

1138

#elif V8_TARGET_ARCH_ARM

1139

#include "arm/codegen-arm-inl.h"

1140

#else

1141

#error Unsupported target architecture.

1142

#endif

1143

1144

1145

+#pragma GCC visibility push(hidden)

1146

1147

namespace v8 {

1148

namespace internal {

1149

1150

#define __ ACCESS_MASM(masm_)

1151

1152

// -----------------------------------------------------------------------------

1153

// Support for "structured" code comments.

1154

1155

@@ -80,9 +82,11 @@

1156

1157

#endif // DEBUG

1158

1159

#undef __

1160

1161

1162

} } // namespace v8::internal

1163

1164

+#pragma GCC visibility pop

1165

1166

#endif // V8_CODEGEN_INL_H_

1167

Index: chromium-v8-1.2.14~svn20090716r2483/src/code.h

1168

===================================================================

1169

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/code.h

1170

+++ chromium-v8-1.2.14~svn20090716r2483/src/code.h

1171

@@ -23,16 +23,18 @@

1172

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1173

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1174

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1175

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1176

1177

#ifndef V8_CODE_H_

1178

#define V8_CODE_H_

1179

1180

+#pragma GCC visibility push(hidden)

1181

1182

namespace v8 {

1183

namespace internal {

1184

1185

1186

// Wrapper class for passing expected and actual parameter counts as

1187

// either registers or immediate values. Used to make sure that the

1188

// caller provides exactly the expected number of parameters to the

1189

// callee.

1190

@@ -60,9 +62,11 @@

1191

const int immediate_;

1192

1193

DISALLOW_IMPLICIT_CONSTRUCTORS(ParameterCount);

1194

};

1195

1196

1197

} } // namespace v8::internal

1198

1199

+#pragma GCC visibility pop

1200

1201

#endif // V8_CODE_H_

1202

Index: chromium-v8-1.2.14~svn20090716r2483/src/code-stubs.h

1203

===================================================================

1204

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/code-stubs.h

1205

+++ chromium-v8-1.2.14~svn20090716r2483/src/code-stubs.h

1206

@@ -23,16 +23,18 @@

1207

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1208

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1209

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1210

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1211

1212

#ifndef V8_CODE_STUBS_H_

1213

#define V8_CODE_STUBS_H_

1214

1215

+#pragma GCC visibility push(hidden)

1216

1217

namespace v8 {

1218

namespace internal {

1219

1220

1221

// Stub is base classes of all stubs.

1222

class CodeStub BASE_EMBEDDED {

1223

public:

1224

enum Major {

1225

@@ -108,9 +110,11 @@

1226

class MajorKeyBits: public BitField<uint32_t, 0, kMajorBits> {};

1227

class MinorKeyBits: public BitField<uint32_t, kMajorBits, kMinorBits> {};

1228

1229

friend class BreakPointIterator;

1230

};

1231

1232

} } // namespace v8::internal

1233

1234

+#pragma GCC visibility pop

1235

1236

#endif // V8_CODE_STUBS_H_

1237

Index: chromium-v8-1.2.14~svn20090716r2483/src/compilation-cache.cc

1238

===================================================================

1239

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/compilation-cache.cc

1240

+++ chromium-v8-1.2.14~svn20090716r2483/src/compilation-cache.cc

1241

@@ -24,16 +24,18 @@

1242

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1243

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1244

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1245

1246

#include "v8.h"

1247

1248

#include "compilation-cache.h"

1249

1250

+#pragma GCC visibility push(hidden)

1251

1252

namespace v8 {

1253

namespace internal {

1254

1255

1256

// The number of sub caches covering the different types to cache.

1257

static const int kSubCacheCount = 4;

1258

1259

// The number of generations for each sub cache.

1260

@@ -473,8 +475,9 @@

1261

1262

void CompilationCache::Disable() {

1263

enabled = false;

1264

Clear();

1265

}

1266

1267

1268

} } // namespace v8::internal

1269

+#pragma GCC visibility pop

1270

Index: chromium-v8-1.2.14~svn20090716r2483/src/compilation-cache.h

1271

===================================================================

1272

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/compilation-cache.h

1273

+++ chromium-v8-1.2.14~svn20090716r2483/src/compilation-cache.h

1274

@@ -23,16 +23,18 @@

1275

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1276

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1277

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1278

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1279

1280

#ifndef V8_COMPILATION_CACHE_H_

1281

#define V8_COMPILATION_CACHE_H_

1282

1283

+#pragma GCC visibility push(hidden)

1284

1285

namespace v8 {

1286

namespace internal {

1287

1288

1289

// The compilation cache keeps function boilerplates for compiled

1290

// scripts and evals. The boilerplates are looked up using the source

1291

// string as the key. For regular expressions the compilation data is cached.

1292

class CompilationCache {

1293

@@ -90,9 +92,11 @@

1294

// cache during debugging to make sure new scripts are always compiled.

1295

static void Enable();

1296

static void Disable();

1297

};

1298

1299

1300

} } // namespace v8::internal

1301

1302

+#pragma GCC visibility pop

1303

1304

#endif // V8_COMPILATION_CACHE_H_

1305

Index: chromium-v8-1.2.14~svn20090716r2483/src/compiler.h

1306

===================================================================

1307

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/compiler.h

1308

+++ chromium-v8-1.2.14~svn20090716r2483/src/compiler.h

1309

@@ -27,16 +27,18 @@

1310

1311

#ifndef V8_COMPILER_H_

1312

#define V8_COMPILER_H_

1313

1314

#include "frame-element.h"

1315

#include "parser.h"

1316

#include "zone.h"

1317

1318

+#pragma GCC visibility push(hidden)

1319

1320

namespace v8 {

1321

namespace internal {

1322

1323

// The V8 compiler

1324

1325

// General strategy: Source code is translated into an anonymous function w/o

1326

// parameters which then can be executed. If the source code contains other

1327

// functions, they will be compiled and allocated as part of the compilation

1328

@@ -84,9 +86,11 @@

1329

Result::ClearConstantList();

1330

}

1331

}

1332

};

1333

1334

1335

} } // namespace v8::internal

1336

1337

+#pragma GCC visibility pop

1338

1339

#endif // V8_COMPILER_H_

1340

Index: chromium-v8-1.2.14~svn20090716r2483/src/contexts.h

1341

===================================================================

1342

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/contexts.h

1343

+++ chromium-v8-1.2.14~svn20090716r2483/src/contexts.h

1344

@@ -23,16 +23,18 @@

1345

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1346

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1347

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1348

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1349

1350

#ifndef V8_CONTEXTS_H_

1351

#define V8_CONTEXTS_H_

1352

1353

+#pragma GCC visibility push(hidden)

1354

1355

namespace v8 {

1356

namespace internal {

1357

1358

1359

enum ContextLookupFlags {

1360

FOLLOW_CONTEXT_CHAIN = 1,

1361

FOLLOW_PROTOTYPE_CHAIN = 2,

1362

1363

@@ -335,9 +337,11 @@

1364

// Bootstrapping-aware type checks.

1365

static bool IsBootstrappingOrContext(Object* object);

1366

static bool IsBootstrappingOrGlobalObject(Object* object);

1367

#endif

1368

};

1369

1370

} } // namespace v8::internal

1371

1372

+#pragma GCC visibility pop

1373

1374

#endif // V8_CONTEXTS_H_

1375

Index: chromium-v8-1.2.14~svn20090716r2483/src/conversions.h

1376

===================================================================

1377

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/conversions.h

1378

+++ chromium-v8-1.2.14~svn20090716r2483/src/conversions.h

1379

@@ -23,16 +23,18 @@

1380

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1381

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1382

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1383

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1384

1385

#ifndef V8_CONVERSIONS_H_

1386

#define V8_CONVERSIONS_H_

1387

1388

+#pragma GCC visibility push(hidden)

1389

1390

namespace v8 {

1391

namespace internal {

1392

1393

// The fast double-to-int conversion routine does not guarantee

1394

// rounding towards zero.

1395

// The result is unspecified if x is infinite or NaN, or if the rounded

1396

// integer value is outside the range of type int.

1397

static inline int FastD2I(double x);

1398

@@ -109,9 +111,11 @@

1399

// The caller is responsible for calling free on the returned pointer.

1400

char* DoubleToFixedCString(double value, int f);

1401

char* DoubleToExponentialCString(double value, int f);

1402

char* DoubleToPrecisionCString(double value, int f);

1403

char* DoubleToRadixCString(double value, int radix);

1404

1405

} } // namespace v8::internal

1406

1407

+#pragma GCC visibility pop

1408

1409

#endif // V8_CONVERSIONS_H_

1410

Index: chromium-v8-1.2.14~svn20090716r2483/src/conversions-inl.h

1411

===================================================================

1412

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/conversions-inl.h

1413

+++ chromium-v8-1.2.14~svn20090716r2483/src/conversions-inl.h

1414

@@ -33,16 +33,18 @@

1415

#include <stdarg.h>

1416

1417

// ----------------------------------------------------------------------------

1418

// Extra POSIX/ANSI functions for Win32/MSVC.

1419

1420

#include "conversions.h"

1421

#include "platform.h"

1422

1423

+#pragma GCC visibility push(hidden)

1424

1425

namespace v8 {

1426

namespace internal {

1427

1428

// The fast double-to-int conversion routine does not guarantee

1429

// rounding towards zero.

1430

static inline int FastD2I(double x) {

1431

#ifdef __USE_ISOC99

1432

// The ISO C99 standard defines the lrint() function which rounds a

1433

@@ -87,9 +89,11 @@

1434

if (x < 0 || x >= two32) x = fmod(x, two32);

1435

x = (x >= 0) ? floor(x) : ceil(x) + two32;

1436

return (int32_t) ((x >= two31) ? x - two32 : x);

1437

}

1438

1439

1440

} } // namespace v8::internal

1441

1442

+#pragma GCC visibility pop

1443

1444

#endif // V8_CONVERSIONS_INL_H_

1445

Index: chromium-v8-1.2.14~svn20090716r2483/src/counters.h

1446

===================================================================

1447

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/counters.h

1448

+++ chromium-v8-1.2.14~svn20090716r2483/src/counters.h

1449

@@ -23,16 +23,18 @@

1450

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1451

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1452

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1453

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1454

1455

#ifndef V8_COUNTERS_H_

1456

#define V8_COUNTERS_H_

1457

1458

+#pragma GCC visibility push(hidden)

1459

1460

namespace v8 {

1461

namespace internal {

1462

1463

// StatsCounters is an interface for plugging into external

1464

// counters for monitoring. Counters can be looked up and

1465

// manipulated by name.

1466

1467

class StatsTable : public AllStatic {

1468

@@ -231,9 +233,11 @@

1469

}

1470

private:

1471

HistogramTimer* timer_;

1472

};

1473

1474

1475

} } // namespace v8::internal

1476

1477

+#pragma GCC visibility pop

1478

1479

#endif // V8_COUNTERS_H_

1480

Index: chromium-v8-1.2.14~svn20090716r2483/src/cpu.h

1481

===================================================================

1482

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/cpu.h

1483

+++ chromium-v8-1.2.14~svn20090716r2483/src/cpu.h

1484

@@ -31,16 +31,18 @@

1485

// The classes have the same definition for all architectures. The

1486

// implementation for a particular architecture is put in cpu_<arch>.cc.

1487

// The build system then uses the implementation for the target architecture.

1488

1489

1490

#ifndef V8_CPU_H_

1491

#define V8_CPU_H_

1492

1493

+#pragma GCC visibility push(hidden)

1494

1495

namespace v8 {

1496

namespace internal {

1497

1498

// ----------------------------------------------------------------------------

1499

// CPU

1500

1501

// This class has static methods for the architecture specific functions. Add

1502

// methods here to cope with differences between the supported architectures.

1503

@@ -57,9 +59,11 @@

1504

static void FlushICache(void* start, size_t size);

1505

1506

// Try to activate a system level debugger.

1507

static void DebugBreak();

1508

};

1509

1510

} } // namespace v8::internal

1511

1512

+#pragma GCC visibility pop

1513

1514

#endif // V8_CPU_H_

1515

Index: chromium-v8-1.2.14~svn20090716r2483/src/d8-debug.h

1516

===================================================================

1517

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/d8-debug.h

1518

+++ chromium-v8-1.2.14~svn20090716r2483/src/d8-debug.h

1519

@@ -28,16 +28,18 @@

1520

#ifndef V8_D8_DEBUG_H_

1521

#define V8_D8_DEBUG_H_

1522

1523

1524

#include "d8.h"

1525

#include "debug.h"

1526

1527

1528

+#pragma GCC visibility push(hidden)

1529

1530

namespace v8 {

1531

1532

1533

void HandleDebugEvent(DebugEvent event,

1534

Handle<Object> exec_state,

1535

Handle<Object> event_data,

1536

Handle<Value> data);

1537

1538

@@ -147,9 +149,11 @@

1539

1540

friend class RemoteDebugger;

1541

};

1542

1543

1544

} // namespace v8

1545

1546

1547

+#pragma GCC visibility pop

1548

1549

#endif // V8_D8_DEBUG_H_

1550

Index: chromium-v8-1.2.14~svn20090716r2483/src/d8.h

1551

===================================================================

1552

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/d8.h

1553

+++ chromium-v8-1.2.14~svn20090716r2483/src/d8.h

1554

@@ -27,16 +27,18 @@

1555

1556

#ifndef V8_D8_H_

1557

#define V8_D8_H_

1558

1559

#include "v8.h"

1560

#include "hashmap.h"

1561

1562

1563

+#pragma GCC visibility push(hidden)

1564

1565

namespace v8 {

1566

1567

1568

namespace i = v8::internal;

1569

1570

1571

// A single counter in a counter collection.

1572

class Counter {

1573

@@ -215,9 +217,11 @@

1574

LineEditor* next_;

1575

static LineEditor* first_;

1576

};

1577

1578

1579

} // namespace v8

1580

1581

1582

+#pragma GCC visibility pop

1583

1584

#endif // V8_D8_H_

1585

Index: chromium-v8-1.2.14~svn20090716r2483/src/dateparser.h

1586

===================================================================

1587

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/dateparser.h

1588

+++ chromium-v8-1.2.14~svn20090716r2483/src/dateparser.h

1589

@@ -25,16 +25,18 @@

1590

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1591

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1592

1593

#ifndef V8_DATEPARSER_H_

1594

#define V8_DATEPARSER_H_

1595

1596

#include "scanner.h"

1597

1598

+#pragma GCC visibility push(hidden)

1599

1600

namespace v8 {

1601

namespace internal {

1602

1603

class DateParser : public AllStatic {

1604

public:

1605

1606

// Parse the string as a date. If parsing succeeds, return true after

1607

// filling out the output array as follows (all integers are Smis):

1608

@@ -232,9 +234,11 @@

1609

int index_;

1610

int named_month_;

1611

};

1612

};

1613

1614

1615

} } // namespace v8::internal

1616

1617

+#pragma GCC visibility pop

1618

1619

#endif // V8_DATEPARSER_H_

1620

Index: chromium-v8-1.2.14~svn20090716r2483/src/dateparser-inl.h

1621

===================================================================

1622

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/dateparser-inl.h

1623

+++ chromium-v8-1.2.14~svn20090716r2483/src/dateparser-inl.h

1624

@@ -23,16 +23,18 @@

1625

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1626

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1627

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1628

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1629

1630

#ifndef V8_DATEPARSER_INL_H_

1631

#define V8_DATEPARSER_INL_H_

1632

1633

+#pragma GCC visibility push(hidden)

1634

1635

namespace v8 {

1636

namespace internal {

1637

1638

template <typename Char>

1639

bool DateParser::Parse(Vector<Char> str, FixedArray* out) {

1640

ASSERT(out->length() >= OUTPUT_SIZE);

1641

InputReader<Char> in(str);

1642

TimeZoneComposer tz;

1643

@@ -104,9 +106,11 @@

1644

in.Next();

1645

}

1646

}

1647

return day.Write(out) && time.Write(out) && tz.Write(out);

1648

}

1649

1650

} } // namespace v8::internal

1651

1652

+#pragma GCC visibility pop

1653

1654

#endif // V8_DATEPARSER_INL_H_

1655

Index: chromium-v8-1.2.14~svn20090716r2483/src/debug-agent.h

1656

===================================================================

1657

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/debug-agent.h

1658

+++ chromium-v8-1.2.14~svn20090716r2483/src/debug-agent.h

1659

@@ -27,16 +27,18 @@

1660

1661

#ifndef V8_DEBUG_AGENT_H_

1662

#define V8_DEBUG_AGENT_H_

1663

1664

#ifdef ENABLE_DEBUGGER_SUPPORT

1665

#include "../include/v8-debug.h"

1666

#include "platform.h"

1667

1668

+#pragma GCC visibility push(hidden)

1669

1670

namespace v8 {

1671

namespace internal {

1672

1673

// Forward decelrations.

1674

class DebuggerAgentSession;

1675

1676

1677

// Debugger agent which starts a socket listener on the debugger port and

1678

@@ -118,9 +120,11 @@

1679

const v8::Handle<v8::String> message);

1680

static int ReceiveAll(const Socket* conn, char* data, int len);

1681

};

1682

1683

} } // namespace v8::internal

1684

1685

#endif // ENABLE_DEBUGGER_SUPPORT

1686

1687

+#pragma GCC visibility pop

1688

1689

#endif // V8_DEBUG_AGENT_H_

1690

Index: chromium-v8-1.2.14~svn20090716r2483/src/debug.h

1691

===================================================================

1692

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/debug.h

1693

+++ chromium-v8-1.2.14~svn20090716r2483/src/debug.h

1694

@@ -36,16 +36,18 @@

1695

#include "hashmap.h"

1696

#include "platform.h"

1697

#include "string-stream.h"

1698

#include "v8threads.h"

1699

1700

#ifdef ENABLE_DEBUGGER_SUPPORT

1701

#include "../include/v8-debug.h"

1702

1703

+#pragma GCC visibility push(hidden)

1704

1705

namespace v8 {

1706

namespace internal {

1707

1708

1709

// Forward declarations.

1710

class EnterDebugger;

1711

1712

1713

@@ -847,9 +849,11 @@

1714

int reg_;

1715

};

1716

1717

1718

} } // namespace v8::internal

1719

1720

#endif // ENABLE_DEBUGGER_SUPPORT

1721

1722

+#pragma GCC visibility pop

1723

1724

#endif // V8_DEBUG_H_

1725

Index: chromium-v8-1.2.14~svn20090716r2483/src/disasm.h

1726

===================================================================

1727

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/disasm.h

1728

+++ chromium-v8-1.2.14~svn20090716r2483/src/disasm.h

1729

@@ -23,16 +23,18 @@

1730

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1731

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1732

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1733

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1734

1735

#ifndef V8_DISASM_H_

1736

#define V8_DISASM_H_

1737

1738

+#pragma GCC visibility push(hidden)

1739

1740

namespace disasm {

1741

1742

typedef unsigned char byte;

1743

1744

// Interface and default implementation for converting addresses and

1745

// register-numbers to text. The default implementation is machine

1746

// specific.

1747

class NameConverter {

1748

@@ -69,9 +71,11 @@

1749

private:

1750

const NameConverter& converter_;

1751

1752

DISALLOW_IMPLICIT_CONSTRUCTORS(Disassembler);

1753

};

1754

1755

} // namespace disasm

1756

1757

+#pragma GCC visibility pop

1758

1759

#endif // V8_DISASM_H_

1760

Index: chromium-v8-1.2.14~svn20090716r2483/src/disassembler.h

1761

===================================================================

1762

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/disassembler.h

1763

+++ chromium-v8-1.2.14~svn20090716r2483/src/disassembler.h

1764

@@ -23,16 +23,18 @@

1765

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1766

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1767

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1768

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1769

1770

#ifndef V8_DISASSEMBLER_H_

1771

#define V8_DISASSEMBLER_H_

1772

1773

+#pragma GCC visibility push(hidden)

1774

1775

namespace v8 {

1776

namespace internal {

1777

1778

class Disassembler : public AllStatic {

1779

public:

1780

// Print the bytes in the interval [begin, end) into f.

1781

static void Dump(FILE* f, byte* begin, byte* end);

1782

1783

@@ -48,9 +50,11 @@

1784

// Returns the instruction length in bytes, or 1 if the instruction could

1785

// not be decoded. The number of characters written is written into

1786

// the out parameter char_count.

1787

static int Decode(FILE* f, byte* pc, int* char_count);

1788

};

1789

1790

} } // namespace v8::internal

1791

1792

+#pragma GCC visibility pop

1793

1794

#endif // V8_DISASSEMBLER_H_

1795

Index: chromium-v8-1.2.14~svn20090716r2483/src/execution.h

1796

===================================================================

1797

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/execution.h

1798

+++ chromium-v8-1.2.14~svn20090716r2483/src/execution.h

1799

@@ -23,16 +23,18 @@

1800

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1801

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1802

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1803

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1804

1805

#ifndef V8_EXECUTION_H_

1806

#define V8_EXECUTION_H_

1807

1808

+#pragma GCC visibility push(hidden)

1809

1810

namespace v8 {

1811

namespace internal {

1812

1813

1814

// Flag used to set the interrupt causes.

1815

enum InterruptFlag {

1816

INTERRUPT = 1 << 0,

1817

DEBUGBREAK = 1 << 1,

1818

@@ -276,9 +278,11 @@

1819

static v8::Handle<v8::Value> GC(const v8::Arguments& args);

1820

private:

1821

static const char* kSource;

1822

};

1823

1824

1825

} } // namespace v8::internal

1826

1827

+#pragma GCC visibility pop

1828

1829

#endif // V8_EXECUTION_H_

1830

Index: chromium-v8-1.2.14~svn20090716r2483/src/factory.h

1831

===================================================================

1832

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/factory.h

1833

+++ chromium-v8-1.2.14~svn20090716r2483/src/factory.h

1834

@@ -27,16 +27,18 @@

1835

1836

#ifndef V8_FACTORY_H_

1837

#define V8_FACTORY_H_

1838

1839

#include "globals.h"

1840

#include "heap.h"

1841

#include "zone-inl.h"

1842

1843

+#pragma GCC visibility push(hidden)

1844

1845

namespace v8 {

1846

namespace internal {

1847

1848

1849

// Interface for handle based allocation.

1850

1851

class Factory : public AllStatic {

1852

public:

1853

@@ -371,9 +373,11 @@

1854

static Handle<MapCache> AddToMapCache(Handle<Context> context,

1855

Handle<FixedArray> keys,

1856

Handle<Map> map);

1857

};

1858

1859

1860

} } // namespace v8::internal

1861

1862

+#pragma GCC visibility pop

1863

1864

#endif // V8_FACTORY_H_

1865

Index: chromium-v8-1.2.14~svn20090716r2483/src/flags.h

1866

===================================================================

1867

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/flags.h

1868

+++ chromium-v8-1.2.14~svn20090716r2483/src/flags.h

1869

@@ -24,16 +24,18 @@

1870

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1871

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1872

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1873

#ifndef V8_FLAGS_H_

1874

#define V8_FLAGS_H_

1875

1876

#include "checks.h"

1877

1878

+#pragma GCC visibility push(hidden)

1879

1880

namespace v8 {

1881

namespace internal {

1882

1883

// Declare all of our flags.

1884

#define FLAG_MODE_DECLARE

1885

#include "flag-definitions.h"

1886

1887

// The global list of all flags.

1888

@@ -73,9 +75,11 @@

1889

static void ResetAllFlags();

1890

1891

// Print help to stdout with flags, types, and default values.

1892

static void PrintHelp();

1893

};

1894

1895

} } // namespace v8::internal

1896

1897

+#pragma GCC visibility pop

1898

1899

#endif // V8_FLAGS_H_

1900

Index: chromium-v8-1.2.14~svn20090716r2483/src/frame-element.h

1901

===================================================================

1902

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/frame-element.h

1903

+++ chromium-v8-1.2.14~svn20090716r2483/src/frame-element.h

1904

@@ -25,16 +25,18 @@

1905

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1906

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1907

1908

#ifndef V8_FRAME_ELEMENT_H_

1909

#define V8_FRAME_ELEMENT_H_

1910

1911

#include "register-allocator-inl.h"

1912

1913

+#pragma GCC visibility push(hidden)

1914

1915

namespace v8 {

1916

namespace internal {

1917

1918

// -------------------------------------------------------------------------

1919

// Virtual frame elements

1920

1921

// The internal elements of the virtual frames. There are several kinds of

1922

// elements:

1923

@@ -230,9 +232,11 @@

1924

class SyncedField: public BitField<uint32_t, 4, 1> {};

1925

class DataField: public BitField<uint32_t, 5, 32 - 6> {};

1926

1927

friend class VirtualFrame;

1928

};

1929

1930

} } // namespace v8::internal

1931

1932

+#pragma GCC visibility pop

1933

1934

#endif // V8_FRAME_ELEMENT_H_

1935

Index: chromium-v8-1.2.14~svn20090716r2483/src/frames.h

1936

===================================================================

1937

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/frames.h

1938

+++ chromium-v8-1.2.14~svn20090716r2483/src/frames.h

1939

@@ -23,16 +23,18 @@

1940

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

1941

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

1942

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

1943

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1944

1945

#ifndef V8_FRAMES_H_

1946

#define V8_FRAMES_H_

1947

1948

+#pragma GCC visibility push(hidden)

1949

1950

namespace v8 {

1951

namespace internal {

1952

1953

typedef uint32_t RegList;

1954

1955

// Get the number of registers in a given register list.

1956

int NumRegs(RegList list);

1957

1958

@@ -679,9 +681,11 @@

1959

1960

private:

1961

StackFrameIterator iterator_;

1962

};

1963

1964

1965

} } // namespace v8::internal

1966

1967

+#pragma GCC visibility pop

1968

1969

#endif // V8_FRAMES_H_

1970

Index: chromium-v8-1.2.14~svn20090716r2483/src/frames-inl.h

1971

===================================================================

1972

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/frames-inl.h

1973

+++ chromium-v8-1.2.14~svn20090716r2483/src/frames-inl.h

1974

@@ -35,16 +35,18 @@

1975

#elif V8_TARGET_ARCH_X64

1976

#include "x64/frames-x64.h"

1977

#elif V8_TARGET_ARCH_ARM

1978

#include "arm/frames-arm.h"

1979

#else

1980

#error Unsupported target architecture.

1981

#endif

1982

1983

+#pragma GCC visibility push(hidden)

1984

1985

namespace v8 {

1986

namespace internal {

1987

1988

1989

inline Address StackHandler::address() const {

1990

return reinterpret_cast<Address>(const_cast<StackHandler*>(this));

1991

}

1992

1993

@@ -206,9 +208,11 @@

1994

void JavaScriptFrameIteratorTemp<Iterator>::Reset() {

1995

iterator_.Reset();

1996

if (!done()) Advance();

1997

}

1998

1999

2000

} } // namespace v8::internal

2001

2002

+#pragma GCC visibility pop

2003

2004

#endif // V8_FRAMES_INL_H_

2005

Index: chromium-v8-1.2.14~svn20090716r2483/src/func-name-inferrer.h

2006

===================================================================

2007

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/func-name-inferrer.h

2008

+++ chromium-v8-1.2.14~svn20090716r2483/src/func-name-inferrer.h

2009

@@ -23,16 +23,18 @@

2010

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2011

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2012

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2013

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2014

2015

#ifndef V8_FUNC_NAME_INFERRER_H_

2016

#define V8_FUNC_NAME_INFERRER_H_

2017

2018

+#pragma GCC visibility push(hidden)

2019

2020

namespace v8 {

2021

namespace internal {

2022

2023

// FuncNameInferrer is a stateful class that is used to perform name

2024

// inference for anonymous functions during static analysis of source code.

2025

// Inference is performed in cases when an anonymous function is assigned

2026

// to a variable or a property (see test-func-name-inference.cc for examples.)

2027

2028

@@ -127,9 +129,11 @@

2029

bool is_entered_;

2030

2031

DISALLOW_COPY_AND_ASSIGN(ScopedFuncNameInferrer);

2032

};

2033

2034

2035

} } // namespace v8::internal

2036

2037

+#pragma GCC visibility pop

2038

2039

#endif // V8_FUNC_NAME_INFERRER_H_

2040

Index: chromium-v8-1.2.14~svn20090716r2483/src/global-handles.h

2041

===================================================================

2042

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/global-handles.h

2043

+++ chromium-v8-1.2.14~svn20090716r2483/src/global-handles.h

2044

@@ -25,16 +25,18 @@

2045

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2046

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2047

2048

#ifndef V8_GLOBAL_HANDLES_H_

2049

#define V8_GLOBAL_HANDLES_H_

2050

2051

#include "list-inl.h"

2052

2053

+#pragma GCC visibility push(hidden)

2054

2055

namespace v8 {

2056

namespace internal {

2057

2058

// Structure for tracking global handles.

2059

// A single list keeps all the allocated global handles.

2060

// Destroyed handles stay in the list but is added to the free list.

2061

// At GC the destroyed global handles are removed from the free list

2062

// and deallocated.

2063

@@ -142,9 +144,11 @@

2064

static Node* first_free_;

2065

static Node* first_free() { return first_free_; }

2066

static void set_first_free(Node* value) { first_free_ = value; }

2067

};

2068

2069

2070

} } // namespace v8::internal

2071

2072

+#pragma GCC visibility pop

2073

2074

#endif // V8_GLOBAL_HANDLES_H_

2075

Index: chromium-v8-1.2.14~svn20090716r2483/src/globals.h

2076

===================================================================

2077

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/globals.h

2078

+++ chromium-v8-1.2.14~svn20090716r2483/src/globals.h

2079

@@ -23,16 +23,18 @@

2080

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2081

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2082

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2083

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2084

2085

#ifndef V8_GLOBALS_H_

2086

#define V8_GLOBALS_H_

2087

2088

+#pragma GCC visibility push(hidden)

2089

2090

namespace v8 {

2091

namespace internal {

2092

2093

// Processor architecture detection. For more info on what's defined, see:

2094

// http://msdn.microsoft.com/en-us/library/b0084kay.aspx

2095

// http://www.agner.org/optimize/calling_conventions.pdf

2096

// or with gcc, run: "echo | gcc -E -dM -"

2097

#if defined(_M_X64) || defined(__x86_64__)

2098

@@ -561,9 +563,11 @@

2099

Dest dest;

2100

memcpy(&dest, &source, sizeof(dest));

2101

return dest;

2102

}

2103

2104

2105

} } // namespace v8::internal

2106

2107

+#pragma GCC visibility pop

2108

2109

#endif // V8_GLOBALS_H_

2110

Index: chromium-v8-1.2.14~svn20090716r2483/src/handles.h

2111

===================================================================

2112

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/handles.h

2113

+++ chromium-v8-1.2.14~svn20090716r2483/src/handles.h

2114

@@ -25,16 +25,18 @@

2115

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2116

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2117

2118

#ifndef V8_HANDLES_H_

2119

#define V8_HANDLES_H_

2120

2121

#include "apiutils.h"

2122

2123

+#pragma GCC visibility push(hidden)

2124

2125

namespace v8 {

2126

namespace internal {

2127

2128

// ----------------------------------------------------------------------------

2129

// A Handle provides a reference to an object that survives relocation by

2130

// the garbage collector.

2131

// Handles are only valid within a HandleScope.

2132

// When a handle is created for an object a cell is allocated in the heap.

2133

@@ -342,9 +344,11 @@

2134

bool has_been_transformed_; // Tells whether the object has been transformed.

2135

int unused_property_fields_; // Captures the unused number of field.

2136

Handle<JSObject> object_; // The object being optimized.

2137

};

2138

2139

2140

} } // namespace v8::internal

2141

2142

+#pragma GCC visibility pop

2143

2144

#endif // V8_HANDLES_H_

2145

Index: chromium-v8-1.2.14~svn20090716r2483/src/handles-inl.h

2146

===================================================================

2147

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/handles-inl.h

2148

+++ chromium-v8-1.2.14~svn20090716r2483/src/handles-inl.h

2149

@@ -28,16 +28,18 @@

2150

2151

#ifndef V8_HANDLES_INL_H_

2152

#define V8_HANDLES_INL_H_

2153

2154

#include "apiutils.h"

2155

#include "handles.h"

2156

#include "api.h"

2157

2158

+#pragma GCC visibility push(hidden)

2159

2160

namespace v8 {

2161

namespace internal {

2162

2163

template<class T>

2164

Handle<T>::Handle(T* obj) {

2165

ASSERT(!obj->IsFailure());

2166

location_ = reinterpret_cast<T**>(HandleScope::CreateHandle(obj));

2167

}

2168

@@ -68,9 +70,11 @@

2169

// allocations.

2170

v8::ImplementationUtilities::CurrentHandleScope()->extensions = extensions_;

2171

}

2172

#endif

2173

2174

2175

} } // namespace v8::internal

2176

2177

+#pragma GCC visibility pop

2178

2179

#endif // V8_HANDLES_INL_H_

2180

Index: chromium-v8-1.2.14~svn20090716r2483/src/hashmap.h

2181

===================================================================

2182

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/hashmap.h

2183

+++ chromium-v8-1.2.14~svn20090716r2483/src/hashmap.h

2184

@@ -23,16 +23,18 @@

2185

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2186

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2187

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2188

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2189

2190

#ifndef V8_HASHMAP_H_

2191

#define V8_HASHMAP_H_

2192

2193

+#pragma GCC visibility push(hidden)

2194

2195

namespace v8 {

2196

namespace internal {

2197

2198

2199

// Allocator defines the memory allocator interface

2200

// used by HashMap and implements a default allocator.

2201

class Allocator BASE_EMBEDDED {

2202

public:

2203

@@ -112,9 +114,11 @@

2204

Entry* Probe(void* key, uint32_t hash);

2205

void Initialize(uint32_t capacity);

2206

void Resize();

2207

};

2208

2209

2210

} } // namespace v8::internal

2211

2212

+#pragma GCC visibility pop

2213

2214

#endif // V8_HASHMAP_H_

2215

Index: chromium-v8-1.2.14~svn20090716r2483/src/heap.h

2216

===================================================================

2217

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/heap.h

2218

+++ chromium-v8-1.2.14~svn20090716r2483/src/heap.h

2219

@@ -25,16 +25,18 @@

2220

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2221

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2222

2223

#ifndef V8_HEAP_H_

2224

#define V8_HEAP_H_

2225

2226

#include "zone-inl.h"

2227

2228

+#pragma GCC visibility push(hidden)

2229

2230

namespace v8 {

2231

namespace internal {

2232

2233

// Defines all the roots in Heap.

2234

#define STRONG_ROOT_LIST(V) \

2235

V(Map, meta_map, MetaMap) \

2236

V(Map, heap_number_map, HeapNumberMap) \

2237

V(Map, short_string_map, ShortStringMap) \

2238

@@ -1460,9 +1462,11 @@

2239

2240

// The count from the end of the previous full GC. Will be zero if there

2241

// was no previous full GC.

2242

int previous_marked_count_;

2243

};

2244

2245

} } // namespace v8::internal

2246

2247

+#pragma GCC visibility pop

2248

2249

#endif // V8_HEAP_H_

2250

Index: chromium-v8-1.2.14~svn20090716r2483/src/heap-inl.h

2251

===================================================================

2252

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/heap-inl.h

2253

+++ chromium-v8-1.2.14~svn20090716r2483/src/heap-inl.h

2254

@@ -26,16 +26,18 @@

2255

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2256

2257

#ifndef V8_HEAP_INL_H_

2258

#define V8_HEAP_INL_H_

2259

2260

#include "log.h"

2261

#include "v8-counters.h"

2262

2263

+#pragma GCC visibility push(hidden)

2264

2265

namespace v8 {

2266

namespace internal {

2267

2268

int Heap::MaxObjectSizeInPagedSpace() {

2269

return Page::kMaxHeapObjectSize;

2270

}

2271

2272

2273

@@ -295,9 +297,11 @@

2274

return old;

2275

}

2276

2277

#endif

2278

2279

2280

} } // namespace v8::internal

2281

2282

+#pragma GCC visibility pop

2283

2284

#endif // V8_HEAP_INL_H_

2285

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/assembler-ia32.h

2286

===================================================================

2287

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/assembler-ia32.h

2288

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/assembler-ia32.h

2289

@@ -32,16 +32,18 @@

2290

// modified significantly by Google Inc.

2291

2292

2293

// A light-weight IA32 Assembler.

2294

2295

#ifndef V8_IA32_ASSEMBLER_IA32_H_

2296

#define V8_IA32_ASSEMBLER_IA32_H_

2297

2298

+#pragma GCC visibility push(hidden)

2299

2300

namespace v8 {

2301

namespace internal {

2302

2303

// CPU Registers.

2304

2305

// 1) We would prefer to use an enum, but enum values are assignment-

2306

// compatible with int, which has caused code-generation bugs.

2307

2308

@@ -861,9 +863,11 @@

2309

Assembler* assembler_;

2310

#ifdef DEBUG

2311

int space_before_;

2312

#endif

2313

};

2314

2315

} } // namespace v8::internal

2316

2317

+#pragma GCC visibility pop

2318

2319

#endif // V8_IA32_ASSEMBLER_IA32_H_

2320

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/assembler-ia32-inl.h

2321

===================================================================

2322

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/assembler-ia32-inl.h

2323

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/assembler-ia32-inl.h

2324

@@ -34,16 +34,18 @@

2325

2326

// A light-weight IA32 Assembler.

2327

2328

#ifndef V8_IA32_ASSEMBLER_IA32_INL_H_

2329

#define V8_IA32_ASSEMBLER_IA32_INL_H_

2330

2331

#include "cpu.h"

2332

2333

+#pragma GCC visibility push(hidden)

2334

2335

namespace v8 {

2336

namespace internal {

2337

2338

Condition NegateCondition(Condition cc) {

2339

return static_cast<Condition>(cc ^ 1);

2340

}

2341

2342

2343

@@ -311,9 +313,11 @@

2344

Operand::Operand(int32_t disp, RelocInfo::Mode rmode) {

2345

// [disp/r]

2346

set_modrm(0, ebp);

2347

set_dispr(disp, rmode);

2348

}

2349

2350

} } // namespace v8::internal

2351

2352

+#pragma GCC visibility pop

2353

2354

#endif // V8_IA32_ASSEMBLER_IA32_INL_H_

2355

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/codegen-ia32.h

2356

===================================================================

2357

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/codegen-ia32.h

2358

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/codegen-ia32.h

2359

@@ -23,16 +23,18 @@

2360

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2361

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2362

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2363

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2364

2365

#ifndef V8_IA32_CODEGEN_IA32_H_

2366

#define V8_IA32_CODEGEN_IA32_H_

2367

2368

+#pragma GCC visibility push(hidden)

2369

2370

namespace v8 {

2371

namespace internal {

2372

2373

// Forward declarations

2374

class DeferredCode;

2375

class RegisterAllocator;

2376

class RegisterFile;

2377

2378

@@ -606,9 +608,11 @@

2379

friend class CodeGeneratorPatcher; // Used in test-log-ia32.cc

2380

2381

DISALLOW_COPY_AND_ASSIGN(CodeGenerator);

2382

};

2383

2384

2385

} } // namespace v8::internal

2386

2387

+#pragma GCC visibility pop

2388

2389

#endif // V8_IA32_CODEGEN_IA32_H_

2390

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/codegen-ia32-inl.h

2391

===================================================================

2392

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/codegen-ia32-inl.h

2393

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/codegen-ia32-inl.h

2394

@@ -24,16 +24,18 @@

2395

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2396

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2397

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2398

2399

2400

#ifndef V8_IA32_CODEGEN_IA32_INL_H_

2401

#define V8_IA32_CODEGEN_IA32_INL_H_

2402

2403

+#pragma GCC visibility push(hidden)

2404

2405

namespace v8 {

2406

namespace internal {

2407

2408

#define __ ACCESS_MASM(masm_)

2409

2410

// Platform-specific inline functions.

2411

2412

void DeferredCode::Jump() { __ jmp(&entry_label_); }

2413

@@ -48,9 +50,11 @@

2414

GenerateFastMathOp(COS, args);

2415

}

2416

2417

2418

#undef __

2419

2420

} } // namespace v8::internal

2421

2422

+#pragma GCC visibility pop

2423

2424

#endif // V8_IA32_CODEGEN_IA32_INL_H_

2425

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/disasm-ia32.cc

2426

===================================================================

2427

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/disasm-ia32.cc

2428

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/disasm-ia32.cc

2429

@@ -27,16 +27,17 @@

2430

2431

#include <assert.h>

2432

#include <stdio.h>

2433

#include <stdarg.h>

2434

2435

#include "v8.h"

2436

#include "disasm.h"

2437

2438

+#pragma GCC visibility push(hidden)

2439

namespace disasm {

2440

2441

enum OperandOrder {

2442

UNSET_OP_ORDER = 0,

2443

REG_OPER_OP_ORDER,

2444

OPER_REG_OP_ORDER

2445

};

2446

2447

@@ -1195,8 +1196,9 @@

2448

fprintf(f, " ");

2449

}

2450

fprintf(f, " %s\n", buffer.start());

2451

}

2452

}

2453

2454

2455

} // namespace disasm

2456

+#pragma GCC visibility pop

2457

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/frames-ia32.h

2458

===================================================================

2459

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/frames-ia32.h

2460

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/frames-ia32.h

2461

@@ -23,16 +23,18 @@

2462

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2463

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2464

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2465

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2466

2467

#ifndef V8_IA32_FRAMES_IA32_H_

2468

#define V8_IA32_FRAMES_IA32_H_

2469

2470

+#pragma GCC visibility push(hidden)

2471

2472

namespace v8 {

2473

namespace internal {

2474

2475

2476

// Register lists

2477

// Note that the bit values must match those used in actual instruction encoding

2478

static const int kNumRegs = 8;

2479

2480

@@ -127,9 +129,11 @@

2481

inline Object* JavaScriptFrame::function_slot_object() const {

2482

const int offset = JavaScriptFrameConstants::kFunctionOffset;

2483

return Memory::Object_at(fp() + offset);

2484

}

2485

2486

2487

} } // namespace v8::internal

2488

2489

+#pragma GCC visibility pop

2490

2491

#endif // V8_IA32_FRAMES_IA32_H_

2492

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/macro-assembler-ia32.h

2493

===================================================================

2494

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/macro-assembler-ia32.h

2495

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/macro-assembler-ia32.h

2496

@@ -25,16 +25,18 @@

2497

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2498

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2499

2500

#ifndef V8_IA32_MACRO_ASSEMBLER_IA32_H_

2501

#define V8_IA32_MACRO_ASSEMBLER_IA32_H_

2502

2503

#include "assembler.h"

2504

2505

+#pragma GCC visibility push(hidden)

2506

2507

namespace v8 {

2508

namespace internal {

2509

2510

// Forward declaration.

2511

class JumpTarget;

2512

2513

2514

// Helper types to make flags easier to read at call sites.

2515

@@ -363,9 +365,11 @@

2516

masm->

2517

#else

2518

#define ACCESS_MASM(masm) masm->

2519

#endif

2520

2521

2522

} } // namespace v8::internal

2523

2524

+#pragma GCC visibility pop

2525

2526

#endif // V8_IA32_MACRO_ASSEMBLER_IA32_H_

2527

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/regexp-macro-assembler-ia32.h

2528

===================================================================

2529

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/regexp-macro-assembler-ia32.h

2530

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/regexp-macro-assembler-ia32.h

2531

@@ -23,16 +23,18 @@

2532

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2533

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2534

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2535

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2536

2537

#ifndef V8_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_

2538

#define V8_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_

2539

2540

+#pragma GCC visibility push(hidden)

2541

2542

namespace v8 {

2543

namespace internal {

2544

2545

class RegExpMacroAssemblerIA32: public RegExpMacroAssembler {

2546

public:

2547

// Type of input string to generate code for.

2548

enum Mode { ASCII = 1, UC16 = 2 };

2549

// Result of calling the generated RegExp code:

2550

@@ -278,9 +280,11 @@

2551

Label backtrack_label_;

2552

Label exit_label_;

2553

Label check_preempt_label_;

2554

Label stack_overflow_label_;

2555

};

2556

2557

}} // namespace v8::internal

2558

2559

+#pragma GCC visibility pop

2560

2561

#endif // V8_IA32_REGEXP_MACRO_ASSEMBLER_IA32_H_

2562

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/register-allocator-ia32.h

2563

===================================================================

2564

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/register-allocator-ia32.h

2565

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/register-allocator-ia32.h

2566

@@ -23,21 +23,25 @@

2567

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2568

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2569

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2570

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2571

2572

#ifndef V8_IA32_REGISTER_ALLOCATOR_IA32_H_

2573

#define V8_IA32_REGISTER_ALLOCATOR_IA32_H_

2574

2575

+#pragma GCC visibility push(hidden)

2576

2577

namespace v8 {

2578

namespace internal {

2579

2580

class RegisterAllocatorConstants : public AllStatic {

2581

public:

2582

static const int kNumRegisters = 5;

2583

static const int kInvalidRegister = -1;

2584

};

2585

2586

2587

} } // namespace v8::internal

2588

2589

+#pragma GCC visibility pop

2590

2591

#endif // V8_IA32_REGISTER_ALLOCATOR_IA32_H_

2592

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/register-allocator-ia32-inl.h

2593

===================================================================

2594

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/register-allocator-ia32-inl.h

2595

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/register-allocator-ia32-inl.h

2596

@@ -25,16 +25,18 @@

2597

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2598

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2599

2600

#ifndef V8_IA32_REGISTER_ALLOCATOR_IA32_INL_H_

2601

#define V8_IA32_REGISTER_ALLOCATOR_IA32_INL_H_

2602

2603

#include "v8.h"

2604

2605

+#pragma GCC visibility push(hidden)

2606

2607

namespace v8 {

2608

namespace internal {

2609

2610

// -------------------------------------------------------------------------

2611

// RegisterAllocator implementation.

2612

2613

bool RegisterAllocator::IsReserved(Register reg) {

2614

// The code for this test relies on the order of register codes.

2615

@@ -74,9 +76,11 @@

2616

Reset();

2617

// The non-reserved edi register is live on JS function entry.

2618

Use(edi); // JS function.

2619

}

2620

2621

2622

} } // namespace v8::internal

2623

2624

+#pragma GCC visibility pop

2625

2626

#endif // V8_IA32_REGISTER_ALLOCATOR_IA32_INL_H_

2627

Index: chromium-v8-1.2.14~svn20090716r2483/src/ia32/virtual-frame-ia32.h

2628

===================================================================

2629

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ia32/virtual-frame-ia32.h

2630

+++ chromium-v8-1.2.14~svn20090716r2483/src/ia32/virtual-frame-ia32.h

2631

@@ -26,16 +26,18 @@

2632

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2633

2634

#ifndef V8_IA32_VIRTUAL_FRAME_IA32_H_

2635

#define V8_IA32_VIRTUAL_FRAME_IA32_H_

2636

2637

#include "register-allocator.h"

2638

#include "scopes.h"

2639

2640

+#pragma GCC visibility push(hidden)

2641

2642

namespace v8 {

2643

namespace internal {

2644

2645

// -------------------------------------------------------------------------

2646

// Virtual frames

2647

2648

// The virtual frame is an abstraction of the physical stack frame. It

2649

// encapsulates the parameters, frame-allocated locals, and the expression

2650

@@ -567,9 +569,11 @@

2651

2652

// Classes that need raw access to the elements_ array.

2653

friend class DeferredCode;

2654

friend class JumpTarget;

2655

};

2656

2657

} } // namespace v8::internal

2658

2659

+#pragma GCC visibility pop

2660

2661

#endif // V8_IA32_VIRTUAL_FRAME_IA32_H_

2662

Index: chromium-v8-1.2.14~svn20090716r2483/src/ic.h

2663

===================================================================

2664

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ic.h

2665

+++ chromium-v8-1.2.14~svn20090716r2483/src/ic.h

2666

@@ -25,16 +25,18 @@

2667

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2668

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2669

2670

#ifndef V8_IC_H_

2671

#define V8_IC_H_

2672

2673

#include "assembler.h"

2674

2675

+#pragma GCC visibility push(hidden)

2676

2677

namespace v8 {

2678

namespace internal {

2679

2680

// IC_UTIL_LIST defines all utility functions called from generated

2681

// inline caching code. The argument for the macro, ICU, is the function name.

2682

#define IC_UTIL_LIST(ICU) \

2683

ICU(LoadIC_Miss) \

2684

ICU(KeyedLoadIC_Miss) \

2685

@@ -390,9 +392,11 @@

2686

static bool PatchInlinedStore(Address address, Object* map);

2687

2688

friend class IC;

2689

};

2690

2691

2692

} } // namespace v8::internal

2693

2694

+#pragma GCC visibility pop

2695

2696

#endif // V8_IC_H_

2697

Index: chromium-v8-1.2.14~svn20090716r2483/src/ic-inl.h

2698

===================================================================

2699

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/ic-inl.h

2700

+++ chromium-v8-1.2.14~svn20090716r2483/src/ic-inl.h

2701

@@ -27,16 +27,18 @@

2702

2703

#ifndef V8_IC_INL_H_

2704

#define V8_IC_INL_H_

2705

2706

#include "ic.h"

2707

#include "debug.h"

2708

#include "macro-assembler.h"

2709

2710

+#pragma GCC visibility push(hidden)

2711

2712

namespace v8 {

2713

namespace internal {

2714

2715

2716

Address IC::address() {

2717

// Get the address of the call.

2718

Address result = pc() - Assembler::kTargetAddrToReturnAddrDist;

2719

2720

@@ -85,9 +87,11 @@

2721

// If the object is a value, we use the prototype map for the cache.

2722

ASSERT(object->IsString() || object->IsNumber() || object->IsBoolean());

2723

return JSObject::cast(object->GetPrototype())->map();

2724

}

2725

2726

2727

} } // namespace v8::internal

2728

2729

+#pragma GCC visibility pop

2730

2731

#endif // V8_IC_INL_H_

2732

Index: chromium-v8-1.2.14~svn20090716r2483/src/interpreter-irregexp.h

2733

===================================================================

2734

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/interpreter-irregexp.h

2735

+++ chromium-v8-1.2.14~svn20090716r2483/src/interpreter-irregexp.h

2736

@@ -25,24 +25,28 @@

2737

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2738

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2739

2740

// A simple interpreter for the Irregexp byte code.

2741

2742

#ifndef V8_INTERPRETER_IRREGEXP_H_

2743

#define V8_INTERPRETER_IRREGEXP_H_

2744

2745

+#pragma GCC visibility push(hidden)

2746

2747

namespace v8 {

2748

namespace internal {

2749

2750

2751

class IrregexpInterpreter {

2752

public:

2753

static bool Match(Handle<ByteArray> code,

2754

Handle<String> subject,

2755

int* captures,

2756

int start_position);

2757

};

2758

2759

2760

} } // namespace v8::internal

2761

2762

+#pragma GCC visibility pop

2763

2764

#endif // V8_INTERPRETER_IRREGEXP_H_

2765

Index: chromium-v8-1.2.14~svn20090716r2483/src/jsregexp.cc

2766

===================================================================

2767

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/jsregexp.cc

2768

+++ chromium-v8-1.2.14~svn20090716r2483/src/jsregexp.cc

2769

@@ -53,16 +53,18 @@

2770

#include "arm/regexp-macro-assembler-arm.h"

2771

#else

2772

#error Unsupported target architecture.

2773

#endif

2774

2775

#include "interpreter-irregexp.h"

2776

2777

2778

+#pragma GCC visibility push(hidden)

2779

2780

namespace v8 {

2781

namespace internal {

2782

2783

2784

Handle<Object> RegExpImpl::CreateRegExpLiteral(Handle<JSFunction> constructor,

2785

Handle<String> pattern,

2786

Handle<String> flags,

2787

bool* has_pending_exception) {

2788

@@ -4487,8 +4489,9 @@

2789

return compiler.Assemble(&macro_assembler,

2790

node,

2791

data->capture_count,

2792

pattern);

2793

#endif // V8_NATIVE_REGEXP

2794

}

2795

2796

}} // namespace v8::internal

2797

+#pragma GCC visibility pop

2798

Index: chromium-v8-1.2.14~svn20090716r2483/src/jsregexp.h

2799

===================================================================

2800

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/jsregexp.h

2801

+++ chromium-v8-1.2.14~svn20090716r2483/src/jsregexp.h

2802

@@ -23,16 +23,18 @@

2803

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2804

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2805

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2806

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2807

2808

#ifndef V8_JSREGEXP_H_

2809

#define V8_JSREGEXP_H_

2810

2811

+#pragma GCC visibility push(hidden)

2812

2813

namespace v8 {

2814

namespace internal {

2815

2816

2817

class RegExpMacroAssembler;

2818

2819

2820

class RegExpImpl {

2821

@@ -1377,9 +1379,11 @@

2822

bool is_ascii);

2823

2824

static void DotPrint(const char* label, RegExpNode* node, bool ignore_case);

2825

};

2826

2827

2828

} } // namespace v8::internal

2829

2830

+#pragma GCC visibility pop

2831

2832

#endif // V8_JSREGEXP_H_

2833

Index: chromium-v8-1.2.14~svn20090716r2483/src/jsregexp-inl.h

2834

===================================================================

2835

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/jsregexp-inl.h

2836

+++ chromium-v8-1.2.14~svn20090716r2483/src/jsregexp-inl.h

2837

@@ -28,16 +28,18 @@

2838

#ifndef V8_JSREGEXP_INL_H_

2839

#define V8_JSREGEXP_INL_H_

2840

2841

2842

#include "jsregexp.h"

2843

#include "regexp-macro-assembler.h"

2844

2845

2846

+#pragma GCC visibility push(hidden)

2847

2848

namespace v8 {

2849

namespace internal {

2850

2851

2852

template <typename C>

2853

bool ZoneSplayTree<C>::Insert(const Key& key, Locator* locator) {

2854

if (is_empty()) {

2855

// If the tree is empty, insert the new node.

2856

@@ -252,9 +254,11 @@

2857

callback->Call(node->key(), node->value());

2858

DoForEach<Node, Callback>(node->right(), callback);

2859

}

2860

2861

2862

}} // namespace v8::internal

2863

2864

2865

+#pragma GCC visibility pop

2866

2867

#endif // V8_JSREGEXP_INL_H_

2868

Index: chromium-v8-1.2.14~svn20090716r2483/src/jump-target.h

2869

===================================================================

2870

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/jump-target.h

2871

+++ chromium-v8-1.2.14~svn20090716r2483/src/jump-target.h

2872

@@ -23,16 +23,18 @@

2873

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2874

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2875

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2876

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2877

2878

#ifndef V8_JUMP_TARGET_H_

2879

#define V8_JUMP_TARGET_H_

2880

2881

+#pragma GCC visibility push(hidden)

2882

2883

namespace v8 {

2884

namespace internal {

2885

2886

// Forward declarations.

2887

class FrameElement;

2888

class Result;

2889

class VirtualFrame;

2890

2891

@@ -269,9 +271,11 @@

2892

#endif

2893

2894

DISALLOW_COPY_AND_ASSIGN(ShadowTarget);

2895

};

2896

2897

2898

} } // namespace v8::internal

2899

2900

+#pragma GCC visibility pop

2901

2902

#endif // V8_JUMP_TARGET_H_

2903

Index: chromium-v8-1.2.14~svn20090716r2483/src/jump-target-inl.h

2904

===================================================================

2905

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/jump-target-inl.h

2906

+++ chromium-v8-1.2.14~svn20090716r2483/src/jump-target-inl.h

2907

@@ -23,16 +23,18 @@

2908

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2909

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2910

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2911

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2912

2913

#ifndef V8_JUMP_TARGET_INL_H_

2914

#define V8_JUMP_TARGET_INL_H_

2915

2916

+#pragma GCC visibility push(hidden)

2917

2918

namespace v8 {

2919

namespace internal {

2920

2921

CodeGenerator* JumpTarget::cgen() {

2922

return CodeGeneratorScope::Current();

2923

}

2924

2925

void JumpTarget::InitializeEntryElement(int index, FrameElement* target) {

2926

@@ -41,9 +43,11 @@

2927

entry_frame_->set_register_location(target->reg(), index);

2928

} else if (target->is_copy()) {

2929

entry_frame_->elements_[target->index()].set_copied();

2930

}

2931

}

2932

2933

} } // namespace v8::internal

2934

2935

+#pragma GCC visibility pop

2936

2937

#endif // V8_JUMP_TARGET_INL_H_

2938

Index: chromium-v8-1.2.14~svn20090716r2483/src/list.h

2939

===================================================================

2940

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/list.h

2941

+++ chromium-v8-1.2.14~svn20090716r2483/src/list.h

2942

@@ -23,16 +23,18 @@

2943

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

2944

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

2945

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2946

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2947

2948

#ifndef V8_LIST_H_

2949

#define V8_LIST_H_

2950

2951

+#pragma GCC visibility push(hidden)

2952

2953

namespace v8 {

2954

namespace internal {

2955

2956

2957

// ----------------------------------------------------------------------------

2958

// The list is a template for very light-weight lists. We are not

2959

// using the STL because we want full control over space and speed of

2960

// the code. This implementation is based on code by Robert Griesemer

2961

@@ -141,9 +143,11 @@

2962

// Add() is inlined, ResizeAdd() called by Add() is inlined except for

2963

// Lists of FrameElements, and ResizeAddInternal() is inlined in ResizeAdd().

2964

template <>

2965

void List<FrameElement,

2966

FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element);

2967

2968

} } // namespace v8::internal

2969

2970

+#pragma GCC visibility pop

2971

2972

#endif // V8_LIST_H_

2973

Index: chromium-v8-1.2.14~svn20090716r2483/src/list-inl.h

2974

===================================================================

2975

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/list-inl.h

2976

+++ chromium-v8-1.2.14~svn20090716r2483/src/list-inl.h

2977

@@ -25,16 +25,18 @@

2978

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

2979

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

2980

2981

#ifndef V8_LIST_INL_H_

2982

#define V8_LIST_INL_H_

2983

2984

#include "list.h"

2985

2986

+#pragma GCC visibility push(hidden)

2987

2988

namespace v8 {

2989

namespace internal {

2990

2991

2992

template<typename T, class P>

2993

void List<T, P>::Add(const T& element) {

2994

if (length_ < capacity_) {

2995

data_[length_++] = element;

2996

@@ -158,9 +160,11 @@

2997

data_ = (capacity > 0) ? NewData(capacity) : NULL;

2998

capacity_ = capacity;

2999

length_ = 0;

3000

}

3001

3002

3003

} } // namespace v8::internal

3004

3005

+#pragma GCC visibility pop

3006

3007

#endif // V8_LIST_INL_H_

3008

Index: chromium-v8-1.2.14~svn20090716r2483/src/log.h

3009

===================================================================

3010

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/log.h

3011

+++ chromium-v8-1.2.14~svn20090716r2483/src/log.h

3012

@@ -26,16 +26,18 @@

3013

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3014

3015

#ifndef V8_LOG_H_

3016

#define V8_LOG_H_

3017

3018

#include "platform.h"

3019

#include "log-utils.h"

3020

3021

+#pragma GCC visibility push(hidden)

3022

3023

namespace v8 {

3024

namespace internal {

3025

3026

// Logger is used for collecting logging information from V8 during

3027

// execution. The result is dumped to a file.

3028

3029

// Available command line flags:

3030

3031

@@ -335,9 +337,11 @@

3032

class StackTracer : public AllStatic {

3033

public:

3034

static void Trace(TickSample* sample);

3035

};

3036

3037

3038

} } // namespace v8::internal

3039

3040

+#pragma GCC visibility pop

3041

3042

#endif // V8_LOG_H_

3043

Index: chromium-v8-1.2.14~svn20090716r2483/src/log-inl.h

3044

===================================================================

3045

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/log-inl.h

3046

+++ chromium-v8-1.2.14~svn20090716r2483/src/log-inl.h

3047

@@ -25,16 +25,18 @@

3048

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3049

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3050

3051

#ifndef V8_LOG_INL_H_

3052

#define V8_LOG_INL_H_

3053

3054

#include "log.h"

3055

3056

+#pragma GCC visibility push(hidden)

3057

3058

namespace v8 {

3059

namespace internal {

3060

3061

3062

// VMState class implementation. A simple stack of VM states held by the

3063

// logger and partially threaded through the call stack. States are pushed by

3064

// VMState construction and popped by destruction.

3065

3066

@@ -118,9 +120,11 @@

3067

}

3068

#endif

3069

}

3070

#endif

3071

3072

3073

} } // namespace v8::internal

3074

3075

+#pragma GCC visibility pop

3076

3077

#endif // V8_LOG_INL_H_

3078

Index: chromium-v8-1.2.14~svn20090716r2483/src/log-utils.h

3079

===================================================================

3080

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/log-utils.h

3081

+++ chromium-v8-1.2.14~svn20090716r2483/src/log-utils.h

3082

@@ -23,16 +23,18 @@

3083

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3084

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3085

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3086

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3087

3088

#ifndef V8_LOG_UTILS_H_

3089

#define V8_LOG_UTILS_H_

3090

3091

+#pragma GCC visibility push(hidden)

3092

3093

namespace v8 {

3094

namespace internal {

3095

3096

#ifdef ENABLE_LOGGING_AND_PROFILING

3097

3098

// A memory buffer that increments its size as you write in it. Size

3099

// is incremented with 'block_size' steps, never exceeding 'max_size'.

3100

// During growth, memory contents are never copied. At the end of the

3101

@@ -280,9 +282,11 @@

3102

ScopedLock sl;

3103

int pos_;

3104

};

3105

3106

#endif // ENABLE_LOGGING_AND_PROFILING

3107

3108

} } // namespace v8::internal

3109

3110

+#pragma GCC visibility pop

3111

3112

#endif // V8_LOG_UTILS_H_

3113

Index: chromium-v8-1.2.14~svn20090716r2483/src/mark-compact.h

3114

===================================================================

3115

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/mark-compact.h

3116

+++ chromium-v8-1.2.14~svn20090716r2483/src/mark-compact.h

3117

@@ -23,16 +23,18 @@

3118

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3119

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3120

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3121

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3122

3123

#ifndef V8_MARK_COMPACT_H_

3124

#define V8_MARK_COMPACT_H_

3125

3126

+#pragma GCC visibility push(hidden)

3127

3128

namespace v8 {

3129

namespace internal {

3130

3131

// Callback function, returns whether an object is alive. The heap size

3132

// of the object is returned in size. It optionally updates the offset

3133

// to the first live object in the page (only used for old and map objects).

3134

typedef bool (*IsAliveFunction)(HeapObject* obj, int* size, int* offset);

3135

3136

@@ -413,9 +415,11 @@

3137

friend class UnmarkObjectVisitor;

3138

static void UnmarkObject(HeapObject* obj);

3139

#endif

3140

};

3141

3142

3143

} } // namespace v8::internal

3144

3145

+#pragma GCC visibility pop

3146

3147

#endif // V8_MARK_COMPACT_H_

3148

Index: chromium-v8-1.2.14~svn20090716r2483/src/memory.h

3149

===================================================================

3150

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/memory.h

3151

+++ chromium-v8-1.2.14~svn20090716r2483/src/memory.h

3152

@@ -23,16 +23,18 @@

3153

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3154

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3155

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3156

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3157

3158

#ifndef V8_MEMORY_H_

3159

#define V8_MEMORY_H_

3160

3161

+#pragma GCC visibility push(hidden)

3162

3163

namespace v8 {

3164

namespace internal {

3165

3166

// Memory provides an interface to 'raw' memory. It encapsulates the casts

3167

// that typically are needed when incompatible pointer types are used.

3168

3169

class Memory {

3170

public:

3171

@@ -62,9 +64,11 @@

3172

3173

static Object*& Object_at(Address addr) {

3174

return *reinterpret_cast<Object**>(addr);

3175

}

3176

};

3177

3178

} } // namespace v8::internal

3179

3180

+#pragma GCC visibility pop

3181

3182

#endif // V8_MEMORY_H_

3183

Index: chromium-v8-1.2.14~svn20090716r2483/src/messages.h

3184

===================================================================

3185

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/messages.h

3186

+++ chromium-v8-1.2.14~svn20090716r2483/src/messages.h

3187

@@ -31,16 +31,18 @@

3188

// structures used by this framework.

3189

3190

#ifndef V8_MESSAGES_H_

3191

#define V8_MESSAGES_H_

3192

3193

#include "handles-inl.h"

3194

3195

// Forward declaration of MessageLocation.

3196

+#pragma GCC visibility push(hidden)

3197

3198

namespace v8 {

3199

namespace internal {

3200

class MessageLocation;

3201

} } // namespace v8::internal

3202

3203

3204

class V8Message {

3205

public:

3206

@@ -104,9 +106,11 @@

3207

static void DefaultMessageReport(const MessageLocation* loc,

3208

Handle<Object> message_obj);

3209

static Handle<String> GetMessage(Handle<Object> data);

3210

static SmartPointer<char> GetLocalizedMessage(Handle<Object> data);

3211

};

3212

3213

} } // namespace v8::internal

3214

3215

+#pragma GCC visibility pop

3216

3217

#endif // V8_MESSAGES_H_

3218

Index: chromium-v8-1.2.14~svn20090716r2483/src/natives.h

3219

===================================================================

3220

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/natives.h

3221

+++ chromium-v8-1.2.14~svn20090716r2483/src/natives.h

3222

@@ -23,16 +23,18 @@

3223

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3224

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3225

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3226

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3227

3228

#ifndef V8_NATIVES_H_

3229

#define V8_NATIVES_H_

3230

3231

+#pragma GCC visibility push(hidden)

3232

3233

namespace v8 {

3234

namespace internal {

3235

3236

typedef bool (*NativeSourceCallback)(Vector<const char> name,

3237

Vector<const char> source,

3238

int index);

3239

3240

enum NativeType {

3241

@@ -55,9 +57,11 @@

3242

static Vector<const char> GetScriptSource(int index);

3243

static Vector<const char> GetScriptName(int index);

3244

};

3245

3246

typedef NativesCollection<CORE> Natives;

3247

3248

} } // namespace v8::internal

3249

3250

+#pragma GCC visibility pop

3251

3252

#endif // V8_NATIVES_H_

3253

Index: chromium-v8-1.2.14~svn20090716r2483/src/objects.h

3254

===================================================================

3255

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/objects.h

3256

+++ chromium-v8-1.2.14~svn20090716r2483/src/objects.h

3257

@@ -103,16 +103,18 @@

3258

DONT_ENUM = v8::DontEnum,

3259

DONT_DELETE = v8::DontDelete,

3260

ABSENT = 16 // Used in runtime to indicate a property is absent.

3261

// ABSENT can never be stored in or returned from a descriptor's attributes

3262

// bitfield. It is only used as a return value meaning the attributes of

3263

// a non-existent property.

3264

};

3265

3266

+#pragma GCC visibility push(hidden)

3267

3268

namespace v8 {

3269

namespace internal {

3270

3271

3272

// PropertyDetails captures type and attributes for a property.

3273

// They are used both in property dictionaries and instance descriptors.

3274

class PropertyDetails BASE_EMBEDDED {

3275

public:

3276

@@ -4740,9 +4742,11 @@

3277

value &= ~(1 << bit_position);

3278

}

3279

return value;

3280

}

3281

};

3282

3283

} } // namespace v8::internal

3284

3285

+#pragma GCC visibility pop

3286

3287

#endif // V8_OBJECTS_H_

3288

Index: chromium-v8-1.2.14~svn20090716r2483/src/objects-inl.h

3289

===================================================================

3290

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/objects-inl.h

3291

+++ chromium-v8-1.2.14~svn20090716r2483/src/objects-inl.h

3292

@@ -35,16 +35,18 @@

3293

#ifndef V8_OBJECTS_INL_H_

3294

#define V8_OBJECTS_INL_H_

3295

3296

#include "objects.h"

3297

#include "contexts.h"

3298

#include "conversions-inl.h"

3299

#include "property.h"

3300

3301

+#pragma GCC visibility push(hidden)

3302

3303

namespace v8 {

3304

namespace internal {

3305

3306

PropertyDetails::PropertyDetails(Smi* smi) {

3307

value_ = smi->value();

3308

}

3309

3310

3311

@@ -2766,9 +2768,11 @@

3312

#undef READ_SHORT_FIELD

3313

#undef WRITE_SHORT_FIELD

3314

#undef READ_BYTE_FIELD

3315

#undef WRITE_BYTE_FIELD

3316

3317

3318

} } // namespace v8::internal

3319

3320

+#pragma GCC visibility pop

3321

3322

#endif // V8_OBJECTS_INL_H_

3323

Index: chromium-v8-1.2.14~svn20090716r2483/src/oprofile-agent.h

3324

===================================================================

3325

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/oprofile-agent.h

3326

+++ chromium-v8-1.2.14~svn20090716r2483/src/oprofile-agent.h

3327

@@ -34,16 +34,18 @@

3328

3329

#ifdef ENABLE_OPROFILE_AGENT

3330

// opagent.h uses uint64_t type, which can be missing in

3331

// system headers (they have __uint64_t), but is defined

3332

// in V8's headers.

3333

#include <opagent.h> // NOLINT

3334

#endif

3335

3336

+#pragma GCC visibility push(hidden)

3337

3338

namespace v8 {

3339

namespace internal {

3340

3341

class OProfileAgent {

3342

public:

3343

static bool Initialize();

3344

static void TearDown();

3345

static void CreateNativeCodeRegion(const char* name,

3346

@@ -61,9 +63,11 @@

3347

// Size of the buffer that is used for composing code areas names.

3348

static const int kFormattingBufSize = 256;

3349

#else

3350

static bool is_enabled() { return false; }

3351

#endif

3352

};

3353

} }

3354

3355

+#pragma GCC visibility pop

3356

3357

#endif // V8_OPROFILE_AGENT_H_

3358

Index: chromium-v8-1.2.14~svn20090716r2483/src/parser.cc

3359

===================================================================

3360

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/parser.cc

3361

+++ chromium-v8-1.2.14~svn20090716r2483/src/parser.cc

3362

@@ -32,16 +32,18 @@

3363

#include "bootstrapper.h"

3364

#include "compiler.h"

3365

#include "platform.h"

3366

#include "runtime.h"

3367

#include "parser.h"

3368

#include "scopes.h"

3369

#include "string-stream.h"

3370

3371

+#pragma GCC visibility push(hidden)

3372

3373

namespace v8 {

3374

namespace internal {

3375

3376

class ParserFactory;

3377

class ParserLog;

3378

class TemporaryScope;

3379

class Target;

3380

3381

@@ -4678,8 +4680,9 @@

3382

return result;

3383

}

3384

3385

3386

#undef NEW

3387

3388

3389

} } // namespace v8::internal

3390

+#pragma GCC visibility pop

3391

Index: chromium-v8-1.2.14~svn20090716r2483/src/parser.h

3392

===================================================================

3393

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/parser.h

3394

+++ chromium-v8-1.2.14~svn20090716r2483/src/parser.h

3395

@@ -26,16 +26,18 @@

3396

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3397

3398

#ifndef V8_PARSER_H_

3399

#define V8_PARSER_H_

3400

3401

#include "scanner.h"

3402

#include "allocation.h"

3403

3404

+#pragma GCC visibility push(hidden)

3405

3406

namespace v8 {

3407

namespace internal {

3408

3409

3410

class ParserMessage : public Malloced {

3411

public:

3412

ParserMessage(Scanner::Location loc, const char* message,

3413

Vector<const char*> args)

3414

@@ -193,9 +195,11 @@

3415

static const int kElementsSlot = 1;

3416

3417

DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);

3418

};

3419

3420

3421

} } // namespace v8::internal

3422

3423

+#pragma GCC visibility pop

3424

3425

#endif // V8_PARSER_H_

3426

Index: chromium-v8-1.2.14~svn20090716r2483/src/platform.h

3427

===================================================================

3428

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/platform.h

3429

+++ chromium-v8-1.2.14~svn20090716r2483/src/platform.h

3430

@@ -100,16 +100,18 @@

3431

#if __GNUC_VERSION__ >= 29600 && __GNUC_VERSION__ < 40100

3432

#include <limits>

3433

#undef V8_INFINITY

3434

#define V8_INFINITY std::numeric_limits<double>::infinity()

3435

#endif

3436

3437

#endif // __GNUC__

3438

3439

+#pragma GCC visibility push(hidden)

3440

3441

namespace v8 {

3442

namespace internal {

3443

3444

class Semaphore;

3445

3446

double ceiling(double x);

3447

3448

// Forward declarations.

3449

@@ -536,9 +538,11 @@

3450

PlatformData* data_; // Platform specific data.

3451

DISALLOW_IMPLICIT_CONSTRUCTORS(Sampler);

3452

};

3453

3454

#endif // ENABLE_LOGGING_AND_PROFILING

3455

3456

} } // namespace v8::internal

3457

3458

+#pragma GCC visibility pop

3459

3460

#endif // V8_PLATFORM_H_

3461

Index: chromium-v8-1.2.14~svn20090716r2483/src/platform-linux.cc

3462

===================================================================

3463

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/platform-linux.cc

3464

+++ chromium-v8-1.2.14~svn20090716r2483/src/platform-linux.cc

3465

@@ -53,16 +53,18 @@

3466

3467

#undef MAP_TYPE

3468

3469

#include "v8.h"

3470

3471

#include "platform.h"

3472

3473

3474

+#pragma GCC visibility push(hidden)

3475

3476

namespace v8 {

3477

namespace internal {

3478

3479

// 0 is never a valid thread id on Linux since tids and pids share a

3480

// name space and pid 0 is reserved (see man 2 kill).

3481

static const pthread_t kNoThread = (pthread_t) 0;

3482

3483

3484

@@ -710,8 +712,9 @@

3485

// This sampler is no longer the active sampler.

3486

active_sampler_ = NULL;

3487

active_ = false;

3488

}

3489

3490

#endif // ENABLE_LOGGING_AND_PROFILING

3491

3492

} } // namespace v8::internal

3493

+#pragma GCC visibility pop

3494

Index: chromium-v8-1.2.14~svn20090716r2483/src/platform-posix.cc

3495

===================================================================

3496

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/platform-posix.cc

3497

+++ chromium-v8-1.2.14~svn20090716r2483/src/platform-posix.cc

3498

@@ -42,16 +42,18 @@

3499

#include <netinet/in.h>

3500

#include <netdb.h>

3501

3502

#include "v8.h"

3503

3504

#include "platform.h"

3505

3506

3507

+#pragma GCC visibility push(hidden)

3508

3509

namespace v8 {

3510

namespace internal {

3511

3512

3513

// ----------------------------------------------------------------------------

3514

// POSIX date/time support.

3515

3516

3517

@@ -344,8 +346,9 @@

3518

3519

3520

Socket* OS::CreateSocket() {

3521

return new POSIXSocket();

3522

}

3523

3524

3525

} } // namespace v8::internal

3526

+#pragma GCC visibility pop

3527

Index: chromium-v8-1.2.14~svn20090716r2483/src/prettyprinter.h

3528

===================================================================

3529

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/prettyprinter.h

3530

+++ chromium-v8-1.2.14~svn20090716r2483/src/prettyprinter.h

3531

@@ -25,16 +25,18 @@

3532

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3533

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3534

3535

#ifndef V8_PRETTYPRINTER_H_

3536

#define V8_PRETTYPRINTER_H_

3537

3538

#include "ast.h"

3539

3540

+#pragma GCC visibility push(hidden)

3541

3542

namespace v8 {

3543

namespace internal {

3544

3545

#ifdef DEBUG

3546

3547

class PrettyPrinter: public AstVisitor {

3548

public:

3549

PrettyPrinter();

3550

@@ -111,9 +113,11 @@

3551

3552

static int indent_;

3553

};

3554

3555

#endif // DEBUG

3556

3557

} } // namespace v8::internal

3558

3559

+#pragma GCC visibility pop

3560

3561

#endif // V8_PRETTYPRINTER_H_

3562

Index: chromium-v8-1.2.14~svn20090716r2483/src/property.h

3563

===================================================================

3564

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/property.h

3565

+++ chromium-v8-1.2.14~svn20090716r2483/src/property.h

3566

@@ -23,16 +23,18 @@

3567

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3568

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3569

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3570

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3571

3572

#ifndef V8_PROPERTY_H_

3573

#define V8_PROPERTY_H_

3574

3575

+#pragma GCC visibility push(hidden)

3576

3577

namespace v8 {

3578

namespace internal {

3579

3580

3581

// Abstraction for elements in instance-descriptor arrays.

3582

3583

// Each descriptor has a key, property attributes, property type,

3584

// property index (in the actual instance-descriptor array) and

3585

@@ -319,9 +321,11 @@

3586

int number_;

3587

bool cacheable_;

3588

PropertyDetails details_;

3589

};

3590

3591

3592

} } // namespace v8::internal

3593

3594

+#pragma GCC visibility pop

3595

3596

#endif // V8_PROPERTY_H_

3597

Index: chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler.h

3598

===================================================================

3599

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/regexp-macro-assembler.h

3600

+++ chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler.h

3601

@@ -23,16 +23,18 @@

3602

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3603

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3604

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3605

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3606

3607

#ifndef V8_REGEXP_MACRO_ASSEMBLER_H_

3608

#define V8_REGEXP_MACRO_ASSEMBLER_H_

3609

3610

+#pragma GCC visibility push(hidden)

3611

3612

namespace v8 {

3613

namespace internal {

3614

3615

struct DisjunctDecisionRow {

3616

RegExpCharacterClass cc;

3617

Label* on_match;

3618

};

3619

3620

@@ -223,9 +225,11 @@

3621

private:

3622

size_t byte_array_size_;

3623

Handle<ByteArray> current_byte_array_;

3624

int current_byte_array_free_offset_;

3625

};

3626

3627

} } // namespace v8::internal

3628

3629

+#pragma GCC visibility pop

3630

3631

#endif // V8_REGEXP_MACRO_ASSEMBLER_H_

3632

Index: chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler-irregexp.h

3633

===================================================================

3634

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/regexp-macro-assembler-irregexp.h

3635

+++ chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler-irregexp.h

3636

@@ -23,16 +23,18 @@

3637

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3638

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3639

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3640

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3641

3642

#ifndef V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_H_

3643

#define V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_H_

3644

3645

+#pragma GCC visibility push(hidden)

3646

3647

namespace v8 {

3648

namespace internal {

3649

3650

3651

class RegExpMacroAssemblerIrregexp: public RegExpMacroAssembler {

3652

public:

3653

// Create an assembler. Instructions and relocation information are emitted

3654

// into a buffer, with the instructions starting from the beginning and the

3655

@@ -140,9 +142,11 @@

3656

3657

static const int kInvalidPC = -1;

3658

3659

DISALLOW_IMPLICIT_CONSTRUCTORS(RegExpMacroAssemblerIrregexp);

3660

};

3661

3662

} } // namespace v8::internal

3663

3664

+#pragma GCC visibility pop

3665

3666

#endif // V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_H_

3667

Index: chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler-irregexp-inl.h

3668

===================================================================

3669

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/regexp-macro-assembler-irregexp-inl.h

3670

+++ chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler-irregexp-inl.h

3671

@@ -30,16 +30,18 @@

3672

3673

#include "v8.h"

3674

#include "ast.h"

3675

#include "bytecodes-irregexp.h"

3676

3677

#ifndef V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_INL_H_

3678

#define V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_INL_H_

3679

3680

+#pragma GCC visibility push(hidden)

3681

3682

namespace v8 {

3683

namespace internal {

3684

3685

3686

void RegExpMacroAssemblerIrregexp::Emit(uint32_t byte,

3687

uint32_t twenty_four_bits) {

3688

uint32_t word = ((twenty_four_bits << BYTECODE_SHIFT) | byte);

3689

ASSERT(pc_ <= buffer_.length());

3690

@@ -68,9 +70,11 @@

3691

}

3692

*reinterpret_cast<uint32_t*>(buffer_.start() + pc_) = word;

3693

pc_ += 4;

3694

}

3695

3696

3697

} } // namespace v8::internal

3698

3699

+#pragma GCC visibility pop

3700

3701

#endif // V8_REGEXP_MACRO_ASSEMBLER_IRREGEXP_INL_H_

3702

Index: chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler-tracer.h

3703

===================================================================

3704

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/regexp-macro-assembler-tracer.h

3705

+++ chromium-v8-1.2.14~svn20090716r2483/src/regexp-macro-assembler-tracer.h

3706

@@ -23,16 +23,18 @@

3707

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3708

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3709

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3710

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3711

3712

#ifndef V8_REGEXP_MACRO_ASSEMBLER_TRACER_H_

3713

#define V8_REGEXP_MACRO_ASSEMBLER_TRACER_H_

3714

3715

+#pragma GCC visibility push(hidden)

3716

3717

namespace v8 {

3718

namespace internal {

3719

3720

// Decorator on a RegExpMacroAssembler that write all calls.

3721

class RegExpMacroAssemblerTracer: public RegExpMacroAssembler {

3722

public:

3723

explicit RegExpMacroAssemblerTracer(RegExpMacroAssembler* assembler);

3724

virtual ~RegExpMacroAssemblerTracer();

3725

@@ -111,9 +113,11 @@

3726

virtual void ClearRegisters(int reg_from, int reg_to);

3727

virtual void WriteStackPointerToRegister(int reg);

3728

private:

3729

RegExpMacroAssembler* assembler_;

3730

};

3731

3732

}} // namespace v8::internal

3733

3734

+#pragma GCC visibility pop

3735

3736

#endif // V8_REGEXP_MACRO_ASSEMBLER_TRACER_H_

3737

Index: chromium-v8-1.2.14~svn20090716r2483/src/regexp-stack.h

3738

===================================================================

3739

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/regexp-stack.h

3740

+++ chromium-v8-1.2.14~svn20090716r2483/src/regexp-stack.h

3741

@@ -23,16 +23,18 @@

3742

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3743

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3744

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3745

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3746

3747

#ifndef V8_REGEXP_STACK_H_

3748

#define V8_REGEXP_STACK_H_

3749

3750

+#pragma GCC visibility push(hidden)

3751

3752

namespace v8 {

3753

namespace internal {

3754

3755

// Maintains a per-v8thread stack area that can be used by irregexp

3756

// implementation for its backtracking stack.

3757

// Since there is only one stack area, the Irregexp implementation is not

3758

// re-entrant. I.e., no regular expressions may be executed in the same thread

3759

// during a preempted Irregexp execution.

3760

@@ -99,9 +101,11 @@

3761

// you have to call EnsureCapacity before using it again.

3762

static void Reset();

3763

3764

static ThreadLocal thread_local_;

3765

};

3766

3767

}} // namespace v8::internal

3768

3769

+#pragma GCC visibility pop

3770

3771

#endif // V8_REGEXP_STACK_H_

3772

Index: chromium-v8-1.2.14~svn20090716r2483/src/register-allocator.h

3773

===================================================================

3774

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/register-allocator.h

3775

+++ chromium-v8-1.2.14~svn20090716r2483/src/register-allocator.h

3776

@@ -35,16 +35,18 @@

3777

#elif V8_TARGET_ARCH_X64

3778

#include "x64/register-allocator-x64.h"

3779

#elif V8_TARGET_ARCH_ARM

3780

#include "arm/register-allocator-arm.h"

3781

#else

3782

#error Unsupported target architecture.

3783

#endif

3784

3785

+#pragma GCC visibility push(hidden)

3786

3787

namespace v8 {

3788

namespace internal {

3789

3790

3791

// -------------------------------------------------------------------------

3792

// Results

3793

3794

// Results encapsulate the compile-time values manipulated by the code

3795

@@ -290,9 +292,11 @@

3796

3797

private:

3798

CodeGenerator* cgen_;

3799

RegisterFile registers_;

3800

};

3801

3802

} } // namespace v8::internal

3803

3804

+#pragma GCC visibility pop

3805

3806

#endif // V8_REGISTER_ALLOCATOR_H_

3807

Index: chromium-v8-1.2.14~svn20090716r2483/src/register-allocator-inl.h

3808

===================================================================

3809

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/register-allocator-inl.h

3810

+++ chromium-v8-1.2.14~svn20090716r2483/src/register-allocator-inl.h

3811

@@ -38,16 +38,18 @@

3812

#include "x64/register-allocator-x64-inl.h"

3813

#elif V8_TARGET_ARCH_ARM

3814

#include "arm/register-allocator-arm-inl.h"

3815

#else

3816

#error Unsupported target architecture.

3817

#endif

3818

3819

3820

+#pragma GCC visibility push(hidden)

3821

3822

namespace v8 {

3823

namespace internal {

3824

3825

Result::~Result() {

3826

if (is_register()) {

3827

CodeGeneratorScope::Current()->allocator()->Unuse(reg());

3828

}

3829

}

3830

@@ -66,9 +68,11 @@

3831

if (is_register()) {

3832

CodeGeneratorScope::Current()->allocator()->Use(reg());

3833

}

3834

}

3835

3836

3837

} } // namespace v8::internal

3838

3839

+#pragma GCC visibility pop

3840

3841

#endif // V8_REGISTER_ALLOCATOR_INL_H_

3842

Index: chromium-v8-1.2.14~svn20090716r2483/src/rewriter.cc

3843

===================================================================

3844

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/rewriter.cc

3845

+++ chromium-v8-1.2.14~svn20090716r2483/src/rewriter.cc

3846

@@ -27,16 +27,18 @@

3847

3848

#include "v8.h"

3849

3850

#include "ast.h"

3851

#include "func-name-inferrer.h"

3852

#include "scopes.h"

3853

#include "rewriter.h"

3854

3855

+#pragma GCC visibility push(hidden)

3856

3857

namespace v8 {

3858

namespace internal {

3859

3860

3861

class AstOptimizer: public AstVisitor {

3862

public:

3863

explicit AstOptimizer() {}

3864

explicit AstOptimizer(Handle<String> enclosing_name) {

3865

@@ -835,8 +837,10 @@

3866

return false;

3867

}

3868

}

3869

return true;

3870

}

3871

3872

3873

} } // namespace v8::internal

3874

3875

+#pragma GCC visibility pop

3876

Index: chromium-v8-1.2.14~svn20090716r2483/src/rewriter.h

3877

===================================================================

3878

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/rewriter.h

3879

+++ chromium-v8-1.2.14~svn20090716r2483/src/rewriter.h

3880

@@ -23,16 +23,18 @@

3881

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3882

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3883

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3884

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3885

3886

#ifndef V8_REWRITER_H_

3887

#define V8_REWRITER_H_

3888

3889

+#pragma GCC visibility push(hidden)

3890

3891

namespace v8 {

3892

namespace internal {

3893

3894

3895

// Currently, the rewriter takes function literals (only top-level)

3896

// and rewrites them to return the value of the last expression in

3897

// them.

3898

3899

@@ -46,9 +48,11 @@

3900

public:

3901

static bool Process(FunctionLiteral* function);

3902

static bool Optimize(FunctionLiteral* function);

3903

};

3904

3905

3906

} } // namespace v8::internal

3907

3908

+#pragma GCC visibility pop

3909

3910

#endif // V8_REWRITER_H_

3911

Index: chromium-v8-1.2.14~svn20090716r2483/src/runtime.h

3912

===================================================================

3913

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/runtime.h

3914

+++ chromium-v8-1.2.14~svn20090716r2483/src/runtime.h

3915

@@ -23,16 +23,18 @@

3916

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

3917

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

3918

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3919

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3920

3921

#ifndef V8_RUNTIME_H_

3922

#define V8_RUNTIME_H_

3923

3924

+#pragma GCC visibility push(hidden)

3925

3926

namespace v8 {

3927

namespace internal {

3928

3929

// The interface to C++ runtime functions.

3930

3931

// ----------------------------------------------------------------------------

3932

// RUNTIME_FUNCTION_LIST_ALWAYS defines runtime calls available in both

3933

// release and debug mode.

3934

@@ -394,9 +396,11 @@

3935

3936

// Helper functions used stubs.

3937

static void PerformGC(Object* result);

3938

};

3939

3940

3941

} } // namespace v8::internal

3942

3943

+#pragma GCC visibility pop

3944

3945

#endif // V8_RUNTIME_H_

3946

Index: chromium-v8-1.2.14~svn20090716r2483/src/scanner.h

3947

===================================================================

3948

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/scanner.h

3949

+++ chromium-v8-1.2.14~svn20090716r2483/src/scanner.h

3950

@@ -26,16 +26,18 @@

3951

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3952

3953

#ifndef V8_SCANNER_H_

3954

#define V8_SCANNER_H_

3955

3956

#include "token.h"

3957

#include "char-predicates-inl.h"

3958

3959

+#pragma GCC visibility push(hidden)

3960

3961

namespace v8 {

3962

namespace internal {

3963

3964

3965

class UTF8Buffer {

3966

public:

3967

UTF8Buffer();

3968

~UTF8Buffer();

3969

@@ -248,9 +250,11 @@

3970

3971

// Decodes a unicode escape-sequence which is part of an identifier.

3972

// If the escape sequence cannot be decoded the result is kBadRune.

3973

uc32 ScanIdentifierUnicodeEscape();

3974

};

3975

3976

} } // namespace v8::internal

3977

3978

+#pragma GCC visibility pop

3979

3980

#endif // V8_SCANNER_H_

3981

Index: chromium-v8-1.2.14~svn20090716r2483/src/scopeinfo.h

3982

===================================================================

3983

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/scopeinfo.h

3984

+++ chromium-v8-1.2.14~svn20090716r2483/src/scopeinfo.h

3985

@@ -25,16 +25,18 @@

3986

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

3987

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

3988

3989

#ifndef V8_SCOPEINFO_H_

3990

#define V8_SCOPEINFO_H_

3991

3992

#include "variables.h"

3993

3994

+#pragma GCC visibility push(hidden)

3995

3996

namespace v8 {

3997

namespace internal {

3998

3999

// Scope information represents information about a functions's

4000

// scopes (currently only one, because we don't do any inlining)

4001

// and the allocation of the scope's variables. Scope information

4002

// is stored in a compressed form with Code objects and is used

4003

// at runtime (stack dumps, deoptimization, etc.).

4004

@@ -228,9 +230,11 @@

4005

4006

static Key keys_[kLength];

4007

static uint32_t values_[kLength];

4008

};

4009

4010

4011

} } // namespace v8::internal

4012

4013

+#pragma GCC visibility pop

4014

4015

#endif // V8_SCOPEINFO_H_

4016

Index: chromium-v8-1.2.14~svn20090716r2483/src/scopes.cc

4017

===================================================================

4018

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/scopes.cc

4019

+++ chromium-v8-1.2.14~svn20090716r2483/src/scopes.cc

4020

@@ -26,16 +26,18 @@

4021

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4022

4023

#include "v8.h"

4024

4025

#include "prettyprinter.h"

4026

#include "scopeinfo.h"

4027

#include "scopes.h"

4028

4029

+#pragma GCC visibility push(hidden)

4030

4031

namespace v8 {

4032

namespace internal {

4033

4034

// ----------------------------------------------------------------------------

4035

// A Zone allocator for use with LocalsMap.

4036

4037

class ZoneAllocator: public Allocator {

4038

public:

4039

@@ -938,8 +940,9 @@

4040

num_heap_slots_ = 0;

4041

}

4042

4043

// Allocation done.

4044

ASSERT(num_heap_slots_ == 0 || num_heap_slots_ >= Context::MIN_CONTEXT_SLOTS);

4045

}

4046

4047

} } // namespace v8::internal

4048

+#pragma GCC visibility pop

4049

Index: chromium-v8-1.2.14~svn20090716r2483/src/scopes.h

4050

===================================================================

4051

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/scopes.h

4052

+++ chromium-v8-1.2.14~svn20090716r2483/src/scopes.h

4053

@@ -26,16 +26,18 @@

4054

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4055

4056

#ifndef V8_SCOPES_H_

4057

#define V8_SCOPES_H_

4058

4059

#include "ast.h"

4060

#include "hashmap.h"

4061

4062

+#pragma GCC visibility push(hidden)

4063

4064

namespace v8 {

4065

namespace internal {

4066

4067

4068

// A hash map to support fast variable declaration and lookup.

4069

class VariableMap: public HashMap {

4070

public:

4071

VariableMap();

4072

@@ -387,9 +389,11 @@

4073

return NULL;

4074

}

4075

virtual VariableProxy* NewTemporary(Handle<String> name) { return NULL; }

4076

};

4077

4078

4079

} } // namespace v8::internal

4080

4081

+#pragma GCC visibility pop

4082

4083

#endif // V8_SCOPES_H_

4084

Index: chromium-v8-1.2.14~svn20090716r2483/src/serialize.h

4085

===================================================================

4086

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/serialize.h

4087

+++ chromium-v8-1.2.14~svn20090716r2483/src/serialize.h

4088

@@ -25,16 +25,18 @@

4089

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4090

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4091

4092

#ifndef V8_SERIALIZE_H_

4093

#define V8_SERIALIZE_H_

4094

4095

#include "hashmap.h"

4096

4097

+#pragma GCC visibility push(hidden)

4098

4099

namespace v8 {

4100

namespace internal {

4101

4102

// A TypeCode is used to distinguish different kinds of external reference.

4103

// It is a single bit to make testing for types easy.

4104

enum TypeCode {

4105

UNCLASSIFIED, // One-of-a-kind references.

4106

BUILTIN,

4107

@@ -335,9 +337,11 @@

4108

bool expect_debug_information_;

4109

#endif

4110

4111

DISALLOW_COPY_AND_ASSIGN(Deserializer);

4112

};

4113

4114

} } // namespace v8::internal

4115

4116

+#pragma GCC visibility pop

4117

4118

#endif // V8_SERIALIZE_H_

4119

Index: chromium-v8-1.2.14~svn20090716r2483/src/shell.h

4120

===================================================================

4121

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/shell.h

4122

+++ chromium-v8-1.2.14~svn20090716r2483/src/shell.h

4123

@@ -27,16 +27,18 @@

4124

4125

// A simple interactive shell. Enable with --shell.

4126

4127

#ifndef V8_SHELL_H_

4128

#define V8_SHELL_H_

4129

4130

#include "../public/debug.h"

4131

4132

+#pragma GCC visibility push(hidden)

4133

4134

namespace v8 {

4135

namespace internal {

4136

4137

// Debug event handler for interactive debugging.

4138

void handle_debug_event(v8::DebugEvent event,

4139

v8::Handle<v8::Object> exec_state,

4140

v8::Handle<v8::Object> event_data,

4141

v8::Handle<Value> data);

4142

@@ -47,9 +49,11 @@

4143

static void PrintObject(v8::Handle<v8::Value> obj);

4144

// Run the read-eval loop, executing code in the specified

4145

// environment.

4146

static void Run(v8::Handle<v8::Context> context);

4147

};

4148

4149

} } // namespace v8::internal

4150

4151

+#pragma GCC visibility pop

4152

4153

#endif // V8_SHELL_H_

4154

Index: chromium-v8-1.2.14~svn20090716r2483/src/smart-pointer.h

4155

===================================================================

4156

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/smart-pointer.h

4157

+++ chromium-v8-1.2.14~svn20090716r2483/src/smart-pointer.h

4158

@@ -23,16 +23,18 @@

4159

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4160

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4161

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4162

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4163

4164

#ifndef V8_SMART_POINTER_H_

4165

#define V8_SMART_POINTER_H_

4166

4167

+#pragma GCC visibility push(hidden)

4168

4169

namespace v8 {

4170

namespace internal {

4171

4172

4173

// A 'scoped array pointer' that calls DeleteArray on its pointer when the

4174

// destructor is called.

4175

template<typename T>

4176

class SmartPointer {

4177

@@ -101,9 +103,11 @@

4178

4179

4180

private:

4181

T* p;

4182

};

4183

4184

} } // namespace v8::internal

4185

4186

+#pragma GCC visibility pop

4187

4188

#endif // V8_SMART_POINTER_H_

4189

Index: chromium-v8-1.2.14~svn20090716r2483/src/snapshot.h

4190

===================================================================

4191

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/snapshot.h

4192

+++ chromium-v8-1.2.14~svn20090716r2483/src/snapshot.h

4193

@@ -23,16 +23,18 @@

4194

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4195

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4196

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4197

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4198

4199

#ifndef V8_SNAPSHOT_H_

4200

#define V8_SNAPSHOT_H_

4201

4202

+#pragma GCC visibility push(hidden)

4203

4204

namespace v8 {

4205

namespace internal {

4206

4207

class Snapshot {

4208

public:

4209

// Initialize the VM from the given snapshot file. If snapshot_file is

4210

// NULL, use the internal snapshot instead. Returns false if no snapshot

4211

// could be found.

4212

@@ -51,9 +53,11 @@

4213

4214

static bool Deserialize(const byte* content, int len);

4215

4216

DISALLOW_IMPLICIT_CONSTRUCTORS(Snapshot);

4217

};

4218

4219

} } // namespace v8::internal

4220

4221

+#pragma GCC visibility pop

4222

4223

#endif // V8_SNAPSHOT_H_

4224

Index: chromium-v8-1.2.14~svn20090716r2483/src/spaces.h

4225

===================================================================

4226

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/spaces.h

4227

+++ chromium-v8-1.2.14~svn20090716r2483/src/spaces.h

4228

@@ -26,16 +26,18 @@

4229

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4230

4231

#ifndef V8_SPACES_H_

4232

#define V8_SPACES_H_

4233

4234

#include "list-inl.h"

4235

#include "log.h"

4236

4237

+#pragma GCC visibility push(hidden)

4238

4239

namespace v8 {

4240

namespace internal {

4241

4242

// -----------------------------------------------------------------------------

4243

// Heap structures:

4244

4245

// A JS heap consists of a young generation, an old generation, and a large

4246

// object space. The young generation is divided into two semispaces. A

4247

@@ -1793,9 +1795,11 @@

4248

private:

4249

LargeObjectChunk* current_;

4250

HeapObjectCallback size_func_;

4251

};

4252

4253

4254

} } // namespace v8::internal

4255

4256

+#pragma GCC visibility pop

4257

4258

#endif // V8_SPACES_H_

4259

Index: chromium-v8-1.2.14~svn20090716r2483/src/spaces-inl.h

4260

===================================================================

4261

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/spaces-inl.h

4262

+++ chromium-v8-1.2.14~svn20090716r2483/src/spaces-inl.h

4263

@@ -26,16 +26,18 @@

4264

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4265

4266

#ifndef V8_SPACES_INL_H_

4267

#define V8_SPACES_INL_H_

4268

4269

#include "memory.h"

4270

#include "spaces.h"

4271

4272

+#pragma GCC visibility push(hidden)

4273

4274

namespace v8 {

4275

namespace internal {

4276

4277

4278

// -----------------------------------------------------------------------------

4279

// HeapObjectIterator

4280

4281

bool HeapObjectIterator::has_next() {

4282

@@ -358,9 +360,11 @@

4283

&& alloc_info->top <= space->high()

4284

&& alloc_info->limit == space->high());

4285

#endif

4286

return obj;

4287

}

4288

4289

} } // namespace v8::internal

4290

4291

+#pragma GCC visibility pop

4292

4293

#endif // V8_SPACES_INL_H_

4294

Index: chromium-v8-1.2.14~svn20090716r2483/src/string-stream.h

4295

===================================================================

4296

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/string-stream.h

4297

+++ chromium-v8-1.2.14~svn20090716r2483/src/string-stream.h

4298

@@ -23,16 +23,18 @@

4299

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4300

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4301

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4302

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4303

4304

#ifndef V8_STRING_STREAM_H_

4305

#define V8_STRING_STREAM_H_

4306

4307

+#pragma GCC visibility push(hidden)

4308

4309

namespace v8 {

4310

namespace internal {

4311

4312

4313

class StringAllocator {

4314

public:

4315

virtual ~StringAllocator() {}

4316

// Allocate a number of bytes.

4317

@@ -190,9 +192,11 @@

4318

int space() const { return capacity_ - length_; }

4319

4320

DISALLOW_IMPLICIT_CONSTRUCTORS(StringStream);

4321

};

4322

4323

4324

} } // namespace v8::internal

4325

4326

+#pragma GCC visibility pop

4327

4328

#endif // V8_STRING_STREAM_H_

4329

Index: chromium-v8-1.2.14~svn20090716r2483/src/stub-cache.h

4330

===================================================================

4331

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/stub-cache.h

4332

+++ chromium-v8-1.2.14~svn20090716r2483/src/stub-cache.h

4333

@@ -25,16 +25,18 @@

4334

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4335

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4336

4337

#ifndef V8_STUB_CACHE_H_

4338

#define V8_STUB_CACHE_H_

4339

4340

#include "macro-assembler.h"

4341

4342

+#pragma GCC visibility push(hidden)

4343

4344

namespace v8 {

4345

namespace internal {

4346

4347

4348

// The stub cache is used for megamorphic calls and property accesses.

4349

// It maps (map, name, type)->Code*

4350

4351

// The design of the table uses the inline cache stubs used for

4352

@@ -553,9 +555,11 @@

4353

const ParameterCount& arguments() { return arguments_; }

4354

4355

Object* GetCode(PropertyType type, String* name);

4356

};

4357

4358

4359

} } // namespace v8::internal

4360

4361

+#pragma GCC visibility pop

4362

4363

#endif // V8_STUB_CACHE_H_

4364

Index: chromium-v8-1.2.14~svn20090716r2483/src/token.h

4365

===================================================================

4366

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/token.h

4367

+++ chromium-v8-1.2.14~svn20090716r2483/src/token.h

4368

@@ -23,16 +23,18 @@

4369

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4370

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4371

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4372

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4373

4374

#ifndef V8_TOKEN_H_

4375

#define V8_TOKEN_H_

4376

4377

+#pragma GCC visibility push(hidden)

4378

4379

namespace v8 {

4380

namespace internal {

4381

4382

// TOKEN_LIST takes a list of 3 macros M, all of which satisfy the

4383

// same signature M(name, string, precedence), where name is the

4384

// symbolic token name, string is the corresponding syntactic symbol

4385

// (or NULL, for literals), and precedence is the precedence (or 0).

4386

// The parameters are invoked for token categories as follows:

4387

@@ -274,9 +276,11 @@

4388

static const char* name_[NUM_TOKENS];

4389

#endif

4390

static const char* string_[NUM_TOKENS];

4391

static int8_t precedence_[NUM_TOKENS];

4392

};

4393

4394

} } // namespace v8::internal

4395

4396

+#pragma GCC visibility pop

4397

4398

#endif // V8_TOKEN_H_

4399

Index: chromium-v8-1.2.14~svn20090716r2483/src/top.h

4400

===================================================================

4401

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/top.h

4402

+++ chromium-v8-1.2.14~svn20090716r2483/src/top.h

4403

@@ -25,16 +25,18 @@

4404

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4405

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4406

4407

#ifndef V8_TOP_H_

4408

#define V8_TOP_H_

4409

4410

#include "frames-inl.h"

4411

4412

+#pragma GCC visibility push(hidden)

4413

4414

namespace v8 {

4415

namespace internal {

4416

4417

4418

#define RETURN_IF_SCHEDULED_EXCEPTION() \

4419

if (Top::has_scheduled_exception()) return Top::PromoteScheduledException()

4420

4421

// Top has static variables used for JavaScript execution.

4422

@@ -398,9 +400,11 @@

4423

class ExecutionAccess BASE_EMBEDDED {

4424

public:

4425

ExecutionAccess();

4426

~ExecutionAccess();

4427

};

4428

4429

} } // namespace v8::internal

4430

4431

+#pragma GCC visibility pop

4432

4433

#endif // V8_TOP_H_

4434

Index: chromium-v8-1.2.14~svn20090716r2483/src/unicode.h

4435

===================================================================

4436

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/unicode.h

4437

+++ chromium-v8-1.2.14~svn20090716r2483/src/unicode.h

4438

@@ -30,16 +30,18 @@

4439

4440

#include <sys/types.h>

4441

4442

/**

4443

* \file

4444

* Definitions and convenience functions for working with unicode.

4445

4446

4447

+#pragma GCC visibility push(hidden)

4448

4449

namespace unibrow {

4450

4451

typedef unsigned int uchar;

4452

typedef unsigned char byte;

4453

4454

/**

4455

* The max length of the result of converting the case of a single

4456

* character.

4457

@@ -271,9 +273,11 @@

4458

static int Convert(uchar c,

4459

uchar n,

4460

uchar* result,

4461

bool* allow_caching_ptr);

4462

};

4463

4464

} // namespace unibrow

4465

4466

+#pragma GCC visibility pop

4467

4468

#endif // V8_UNICODE_H_

4469

Index: chromium-v8-1.2.14~svn20090716r2483/src/unicode-inl.h

4470

===================================================================

4471

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/unicode-inl.h

4472

+++ chromium-v8-1.2.14~svn20090716r2483/src/unicode-inl.h

4473

@@ -25,16 +25,18 @@

4474

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4475

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4476

4477

#ifndef V8_UNICODE_INL_H_

4478

#define V8_UNICODE_INL_H_

4479

4480

#include "unicode.h"

4481

4482

+#pragma GCC visibility push(hidden)

4483

4484

namespace unibrow {

4485

4486

template <class T, int s> bool Predicate<T, s>::get(uchar code_point) {

4487

CacheEntry entry = entries_[code_point & kMask];

4488

if (entry.code_point_ == code_point) return entry.value_;

4489

return CalculateValue(code_point);

4490

}

4491

4492

@@ -230,9 +232,11 @@

4493

template <unsigned s>

4494

Utf8InputBuffer<s>::Utf8InputBuffer(const char* data, unsigned length)

4495

: InputBuffer<Utf8, Buffer<const char*>, s>(Buffer<const char*>(data,

4496

length)) {

4497

}

4498

4499

} // namespace unibrow

4500

4501

+#pragma GCC visibility pop

4502

4503

#endif // V8_UNICODE_INL_H_

4504

Index: chromium-v8-1.2.14~svn20090716r2483/src/usage-analyzer.cc

4505

===================================================================

4506

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/usage-analyzer.cc

4507

+++ chromium-v8-1.2.14~svn20090716r2483/src/usage-analyzer.cc

4508

@@ -26,16 +26,18 @@

4509

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4510

4511

#include "v8.h"

4512

4513

#include "ast.h"

4514

#include "scopes.h"

4515

#include "usage-analyzer.h"

4516

4517

+#pragma GCC visibility push(hidden)

4518

4519

namespace v8 {

4520

namespace internal {

4521

4522

// Weight boundaries

4523

static const int MinWeight = 1;

4524

static const int MaxWeight = 1000000;

4525

static const int InitialWeight = 100;

4526

4527

@@ -445,8 +447,9 @@

4528

4529

bool AnalyzeVariableUsage(FunctionLiteral* lit) {

4530

if (!FLAG_usage_computation) return true;

4531

HistogramTimerScope timer(&Counters::usage_analysis);

4532

return UsageComputer::Traverse(lit);

4533

}

4534

4535

} } // namespace v8::internal

4536

+#pragma GCC visibility pop

4537

Index: chromium-v8-1.2.14~svn20090716r2483/src/usage-analyzer.h

4538

===================================================================

4539

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/usage-analyzer.h

4540

+++ chromium-v8-1.2.14~svn20090716r2483/src/usage-analyzer.h

4541

@@ -23,18 +23,22 @@

4542

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4543

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4544

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4545

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4546

4547

#ifndef V8_USAGE_ANALYZER_H_

4548

#define V8_USAGE_ANALYZER_H_

4549

4550

+#pragma GCC visibility push(hidden)

4551

4552

namespace v8 {

4553

namespace internal {

4554

4555

// Compute usage counts for all variables.

4556

// Used for variable allocation.

4557

bool AnalyzeVariableUsage(FunctionLiteral* lit);

4558

4559

} } // namespace v8::internal

4560

4561

+#pragma GCC visibility pop

4562

4563

#endif // V8_USAGE_ANALYZER_H_

4564

Index: chromium-v8-1.2.14~svn20090716r2483/src/utils.h

4565

===================================================================

4566

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/utils.h

4567

+++ chromium-v8-1.2.14~svn20090716r2483/src/utils.h

4568

@@ -25,16 +25,18 @@

4569

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4570

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4571

4572

#ifndef V8_UTILS_H_

4573

#define V8_UTILS_H_

4574

4575

#include <stdlib.h>

4576

4577

+#pragma GCC visibility push(hidden)

4578

4579

namespace v8 {

4580

namespace internal {

4581

4582

// ----------------------------------------------------------------------------

4583

// General helper functions

4584

4585

// Returns true iff x is a power of 2. Does not work for zero.

4586

template <typename T>

4587

@@ -571,9 +573,11 @@

4588

while (dest < limit) {

4589

*dest++ = static_cast<sinkchar>(*src++);

4590

}

4591

}

4592

4593

4594

} } // namespace v8::internal

4595

4596

+#pragma GCC visibility pop

4597

4598

#endif // V8_UTILS_H_

4599

Index: chromium-v8-1.2.14~svn20090716r2483/src/v8-counters.h

4600

===================================================================

4601

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/v8-counters.h

4602

+++ chromium-v8-1.2.14~svn20090716r2483/src/v8-counters.h

4603

@@ -25,16 +25,18 @@

4604

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4605

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4606

4607

#ifndef V8_V8_COUNTERS_H_

4608

#define V8_V8_COUNTERS_H_

4609

4610

#include "counters.h"

4611

4612

+#pragma GCC visibility push(hidden)

4613

4614

namespace v8 {

4615

namespace internal {

4616

4617

#define HISTOGRAM_TIMER_LIST(HT) \

4618

/* Garbage collection timers. */ \

4619

HT(gc_compactor, V8.GCCompactor) \

4620

HT(gc_scavenger, V8.GCScavenger) \

4621

HT(gc_context, V8.GCContext) /* GC context cleanup time */ \

4622

@@ -177,9 +179,11 @@

4623

};

4624

4625

// Sliding state window counters.

4626

static StatsCounter state_counters[];

4627

};

4628

4629

} } // namespace v8::internal

4630

4631

+#pragma GCC visibility pop

4632

4633

#endif // V8_V8_COUNTERS_H_

4634

Index: chromium-v8-1.2.14~svn20090716r2483/src/v8.h

4635

===================================================================

4636

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/v8.h

4637

+++ chromium-v8-1.2.14~svn20090716r2483/src/v8.h

4638

@@ -69,16 +69,18 @@

4639

#include "spaces.h"

4640

#include "heap.h"

4641

#include "objects-inl.h"

4642

#include "spaces-inl.h"

4643

#include "heap-inl.h"

4644

#include "log-inl.h"

4645

#include "messages.h"

4646

4647

+#pragma GCC visibility push(hidden)

4648

4649

namespace v8 {

4650

namespace internal {

4651

4652

class V8 : public AllStatic {

4653

public:

4654

// Global actions.

4655

4656

// If Initialize is called with des == NULL, the initial state is

4657

@@ -111,9 +113,11 @@

4658

// (reset if engine is restarted)

4659

static bool has_been_disposed_;

4660

};

4661

4662

} } // namespace v8::internal

4663

4664

namespace i = v8::internal;

4665

4666

+#pragma GCC visibility pop

4667

4668

#endif // V8_V8_H_

4669

Index: chromium-v8-1.2.14~svn20090716r2483/src/v8threads.h

4670

===================================================================

4671

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/v8threads.h

4672

+++ chromium-v8-1.2.14~svn20090716r2483/src/v8threads.h

4673

@@ -23,16 +23,18 @@

4674

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4675

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4676

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4677

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4678

4679

#ifndef V8_V8THREADS_H_

4680

#define V8_V8THREADS_H_

4681

4682

+#pragma GCC visibility push(hidden)

4683

4684

namespace v8 {

4685

namespace internal {

4686

4687

4688

class ThreadState {

4689

public:

4690

// Iterate over in-use states.

4691

static ThreadState* FirstInUse();

4692

@@ -124,9 +126,11 @@

4693

bool keep_going_;

4694

int sleep_ms_;

4695

4696

static ContextSwitcher* singleton_;

4697

};

4698

4699

} } // namespace v8::internal

4700

4701

+#pragma GCC visibility pop

4702

4703

#endif // V8_V8THREADS_H_

4704

Index: chromium-v8-1.2.14~svn20090716r2483/src/variables.h

4705

===================================================================

4706

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/variables.h

4707

+++ chromium-v8-1.2.14~svn20090716r2483/src/variables.h

4708

@@ -25,16 +25,18 @@

4709

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4710

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4711

4712

#ifndef V8_VARIABLES_H_

4713

#define V8_VARIABLES_H_

4714

4715

#include "zone.h"

4716

4717

+#pragma GCC visibility push(hidden)

4718

4719

namespace v8 {

4720

namespace internal {

4721

4722

class UseCount BASE_EMBEDDED {

4723

public:

4724

UseCount();

4725

4726

// Inform the node of a "use". The weight can be used to indicate

4727

@@ -223,9 +225,11 @@

4728

Expression* rewrite_;

4729

4730

friend class Scope; // Has explicit access to rewrite_.

4731

};

4732

4733

4734

} } // namespace v8::internal

4735

4736

+#pragma GCC visibility pop

4737

4738

#endif // V8_VARIABLES_H_

4739

Index: chromium-v8-1.2.14~svn20090716r2483/src/version.h

4740

===================================================================

4741

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/version.h

4742

+++ chromium-v8-1.2.14~svn20090716r2483/src/version.h

4743

@@ -23,16 +23,18 @@

4744

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4745

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4746

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4747

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4748

4749

#ifndef V8_VERSION_H_

4750

#define V8_VERSION_H_

4751

4752

+#pragma GCC visibility push(hidden)

4753

4754

namespace v8 {

4755

namespace internal {

4756

4757

class Version {

4758

public:

4759

// Return the various version components.

4760

static int GetMajor() { return major_; }

4761

static int GetMinor() { return minor_; }

4762

@@ -56,9 +58,11 @@

4763

4764

// In test-version.cc.

4765

friend void SetVersion(int major, int minor, int build, int patch,

4766

bool candidate, const char* soname);

4767

};

4768

4769

} } // namespace v8::internal

4770

4771

+#pragma GCC visibility pop

4772

4773

#endif // V8_VERSION_H_

4774

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/assembler-x64.h

4775

===================================================================

4776

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/assembler-x64.h

4777

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/assembler-x64.h

4778

@@ -32,16 +32,18 @@

4779

// modified significantly by Google Inc.

4780

4781

4782

// A lightweight X64 Assembler.

4783

4784

#ifndef V8_X64_ASSEMBLER_X64_H_

4785

#define V8_X64_ASSEMBLER_X64_H_

4786

4787

+#pragma GCC visibility push(hidden)

4788

4789

namespace v8 {

4790

namespace internal {

4791

4792

// Utility functions

4793

4794

// Test whether a 64-bit value is in a specific range.

4795

static inline bool is_uint32(int64_t x) {

4796

const int64_t kUInt32Mask = V8_INT64_C(0xffffffff);

4797

@@ -1200,9 +1202,11 @@

4798

Assembler* assembler_;

4799

#ifdef DEBUG

4800

int space_before_;

4801

#endif

4802

};

4803

4804

} } // namespace v8::internal

4805

4806

+#pragma GCC visibility pop

4807

4808

#endif // V8_X64_ASSEMBLER_X64_H_

4809

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/assembler-x64-inl.h

4810

===================================================================

4811

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/assembler-x64-inl.h

4812

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/assembler-x64-inl.h

4813

@@ -26,16 +26,18 @@

4814

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4815

4816

#ifndef V8_X64_ASSEMBLER_X64_INL_H_

4817

#define V8_X64_ASSEMBLER_X64_INL_H_

4818

4819

#include "cpu.h"

4820

#include "memory.h"

4821

4822

+#pragma GCC visibility push(hidden)

4823

4824

namespace v8 {

4825

namespace internal {

4826

4827

Condition NegateCondition(Condition cc) {

4828

return static_cast<Condition>(cc ^ 1);

4829

}

4830

4831

// -----------------------------------------------------------------------------

4832

@@ -302,9 +304,11 @@

4833

int32_t* p = reinterpret_cast<int32_t*>(&buf_[len_]);

4834

*p = disp;

4835

len_ += sizeof(int32_t);

4836

}

4837

4838

4839

} } // namespace v8::internal

4840

4841

+#pragma GCC visibility pop

4842

4843

#endif // V8_X64_ASSEMBLER_X64_INL_H_

4844

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/codegen-x64.h

4845

===================================================================

4846

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/codegen-x64.h

4847

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/codegen-x64.h

4848

@@ -23,16 +23,18 @@

4849

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4850

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4851

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4852

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4853

4854

#ifndef V8_X64_CODEGEN_X64_H_

4855

#define V8_X64_CODEGEN_X64_H_

4856

4857

+#pragma GCC visibility push(hidden)

4858

4859

namespace v8 {

4860

namespace internal {

4861

4862

// Forward declarations

4863

class DeferredCode;

4864

class RegisterAllocator;

4865

class RegisterFile;

4866

4867

@@ -594,9 +596,11 @@

4868

friend class Result;

4869

4870

DISALLOW_COPY_AND_ASSIGN(CodeGenerator);

4871

};

4872

4873

4874

} } // namespace v8::internal

4875

4876

+#pragma GCC visibility pop

4877

4878

#endif // V8_X64_CODEGEN_X64_H_

4879

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/codegen-x64-inl.h

4880

===================================================================

4881

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/codegen-x64-inl.h

4882

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/codegen-x64-inl.h

4883

@@ -24,16 +24,18 @@

4884

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4885

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4886

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4887

4888

4889

#ifndef V8_X64_CODEGEN_X64_INL_H_

4890

#define V8_X64_CODEGEN_X64_INL_H_

4891

4892

+#pragma GCC visibility push(hidden)

4893

4894

namespace v8 {

4895

namespace internal {

4896

4897

#define __ ACCESS_MASM(masm_)

4898

4899

// Platform-specific inline functions.

4900

4901

void DeferredCode::Jump() { __ jmp(&entry_label_); }

4902

@@ -48,9 +50,11 @@

4903

void CodeGenerator::GenerateMathCos(ZoneList<Expression*>* args) {

4904

GenerateFastMathOp(COS, args);

4905

}

4906

4907

#undef __

4908

4909

} } // namespace v8::internal

4910

4911

+#pragma GCC visibility pop

4912

4913

#endif // V8_X64_CODEGEN_X64_INL_H_

4914

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/frames-x64.h

4915

===================================================================

4916

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/frames-x64.h

4917

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/frames-x64.h

4918

@@ -23,16 +23,18 @@

4919

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4920

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4921

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4922

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4923

4924

#ifndef V8_X64_FRAMES_X64_H_

4925

#define V8_X64_FRAMES_X64_H_

4926

4927

+#pragma GCC visibility push(hidden)

4928

4929

namespace v8 {

4930

namespace internal {

4931

4932

// TODO(x64): This is a stub, mostly just a copy of the ia32 bit version.

4933

// This might all need to change to be correct for x64.

4934

4935

static const int kNumRegs = 8;

4936

static const RegList kJSCallerSaved =

4937

@@ -113,9 +115,11 @@

4938

4939

inline Object* JavaScriptFrame::function_slot_object() const {

4940

const int offset = JavaScriptFrameConstants::kFunctionOffset;

4941

return Memory::Object_at(fp() + offset);

4942

}

4943

4944

} } // namespace v8::internal

4945

4946

+#pragma GCC visibility pop

4947

4948

#endif // V8_X64_FRAMES_X64_H_

4949

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/macro-assembler-x64.h

4950

===================================================================

4951

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/macro-assembler-x64.h

4952

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/macro-assembler-x64.h

4953

@@ -25,16 +25,18 @@

4954

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4955

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4956

4957

#ifndef V8_X64_MACRO_ASSEMBLER_X64_H_

4958

#define V8_X64_MACRO_ASSEMBLER_X64_H_

4959

4960

#include "assembler.h"

4961

4962

+#pragma GCC visibility push(hidden)

4963

4964

namespace v8 {

4965

namespace internal {

4966

4967

// Default scratch register used by MacroAssembler (and other code that needs

4968

// a spare register). The register isn't callee save, and not used by the

4969

// function calling convention.

4970

static const Register kScratchRegister = r10;

4971

4972

@@ -397,9 +399,11 @@

4973

masm->

4974

#else

4975

#define ACCESS_MASM(masm) masm->

4976

#endif

4977

4978

4979

} } // namespace v8::internal

4980

4981

+#pragma GCC visibility pop

4982

4983

#endif // V8_X64_MACRO_ASSEMBLER_X64_H_

4984

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/register-allocator-x64.h

4985

===================================================================

4986

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/register-allocator-x64.h

4987

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/register-allocator-x64.h

4988

@@ -23,23 +23,27 @@

4989

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

4990

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

4991

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

4992

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

4993

4994

#ifndef V8_X64_REGISTER_ALLOCATOR_X64_H_

4995

#define V8_X64_REGISTER_ALLOCATOR_X64_H_

4996

4997

+#pragma GCC visibility push(hidden)

4998

4999

namespace v8 {

5000

namespace internal {

5001

5002

class RegisterAllocatorConstants : public AllStatic {

5003

public:

5004

// Register allocation is not yet implemented on x64, but C++

5005

// forbids 0-length arrays so we use 1 as the number of registers.

5006

static const int kNumRegisters = 12;

5007

static const int kInvalidRegister = -1;

5008

};

5009

5010

5011

} } // namespace v8::internal

5012

5013

+#pragma GCC visibility pop

5014

5015

#endif // V8_X64_REGISTER_ALLOCATOR_X64_H_

5016

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/register-allocator-x64-inl.h

5017

===================================================================

5018

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/register-allocator-x64-inl.h

5019

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/register-allocator-x64-inl.h

5020

@@ -25,16 +25,18 @@

5021

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

5022

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

5023

5024

#ifndef V8_X64_REGISTER_ALLOCATOR_X64_INL_H_

5025

#define V8_X64_REGISTER_ALLOCATOR_X64_INL_H_

5026

5027

#include "v8.h"

5028

5029

+#pragma GCC visibility push(hidden)

5030

5031

namespace v8 {

5032

namespace internal {

5033

5034

// -------------------------------------------------------------------------

5035

// RegisterAllocator implementation.

5036

5037

bool RegisterAllocator::IsReserved(Register reg) {

5038

return reg.is(rsp) || reg.is(rbp) || reg.is(rsi) ||

5039

@@ -78,9 +80,11 @@

5040

5041

void RegisterAllocator::Initialize() {

5042

Reset();

5043

// The non-reserved rdi register is live on JS function entry.

5044

Use(rdi); // JS function.

5045

}

5046

} } // namespace v8::internal

5047

5048

+#pragma GCC visibility pop

5049

5050

#endif // V8_X64_REGISTER_ALLOCATOR_X64_INL_H_

5051

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/simulator-x64.h

5052

===================================================================

5053

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/simulator-x64.h

5054

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/simulator-x64.h

5055

@@ -40,9 +40,11 @@

5056

// the address of "this" to get a value on the current execution stack and then

5057

// calculates the stack limit based on that value.

5058

// NOTE: The check for overflow is not safe as there is no guarantee that the

5059

// running thread has its stack in all memory up to address 0x00000000.

5060

#define GENERATED_CODE_STACK_LIMIT(limit) \

5061

(reinterpret_cast<uintptr_t>(this) >= limit ? \

5062

reinterpret_cast<uintptr_t>(this) - limit : 0)

5063

5064

+#pragma GCC visibility pop

5065

5066

#endif // V8_X64_SIMULATOR_X64_H_

5067

Index: chromium-v8-1.2.14~svn20090716r2483/src/x64/virtual-frame-x64.h

5068

===================================================================

5069

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/x64/virtual-frame-x64.h

5070

+++ chromium-v8-1.2.14~svn20090716r2483/src/x64/virtual-frame-x64.h

5071

@@ -26,16 +26,18 @@

5072

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

5073

5074

#ifndef V8_X64_VIRTUAL_FRAME_X64_H_

5075

#define V8_X64_VIRTUAL_FRAME_X64_H_

5076

5077

#include "register-allocator.h"

5078

#include "scopes.h"

5079

5080

+#pragma GCC visibility push(hidden)

5081

5082

namespace v8 {

5083

namespace internal {

5084

5085

// -------------------------------------------------------------------------

5086

// Virtual frames

5087

5088

// The virtual frame is an abstraction of the physical stack frame. It

5089

// encapsulates the parameters, frame-allocated locals, and the expression

5090

@@ -547,9 +549,11 @@

5091

// Classes that need raw access to the elements_ array.

5092

friend class DeferredCode;

5093

friend class JumpTarget;

5094

};

5095

5096

5097

} } // namespace v8::internal

5098

5099

+#pragma GCC visibility pop

5100

5101

#endif // V8_X64_VIRTUAL_FRAME_X64_H_

5102

Index: chromium-v8-1.2.14~svn20090716r2483/src/zone.h

5103

===================================================================

5104

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/zone.h

5105

+++ chromium-v8-1.2.14~svn20090716r2483/src/zone.h

5106

@@ -23,16 +23,18 @@

5107

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

5108

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

5109

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

5110

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

5111

5112

#ifndef V8_ZONE_H_

5113

#define V8_ZONE_H_

5114

5115

+#pragma GCC visibility push(hidden)

5116

5117

namespace v8 {

5118

namespace internal {

5119

5120

5121

// Zone scopes are in one of two modes. Either they delete the zone

5122

// on exit or they do not.

5123

enum ZoneScopeMode {

5124

DELETE_ON_EXIT,

5125

@@ -201,9 +203,11 @@

5126

private:

5127

ZoneScopeMode mode_;

5128

static int nesting_;

5129

};

5130

5131

5132

} } // namespace v8::internal

5133

5134

+#pragma GCC visibility pop

5135

5136

#endif // V8_ZONE_H_

5137

Index: chromium-v8-1.2.14~svn20090716r2483/src/zone-inl.h

5138

===================================================================

5139

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/zone-inl.h

5140

+++ chromium-v8-1.2.14~svn20090716r2483/src/zone-inl.h

5141

@@ -26,16 +26,18 @@

5142

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

5143

5144

#ifndef V8_ZONE_INL_H_

5145

#define V8_ZONE_INL_H_

5146

5147

#include "zone.h"

5148

#include "v8-counters.h"

5149

5150

+#pragma GCC visibility push(hidden)

5151

5152

namespace v8 {

5153

namespace internal {

5154

5155

5156

inline void* Zone::New(int size) {

5157

ASSERT(AssertNoZoneAllocation::allow_allocation());

5158

ASSERT(ZoneScope::nesting() > 0);

5159

// Round up the requested size to fit the alignment.

5160

@@ -65,9 +67,11 @@

5161

void Zone::adjust_segment_bytes_allocated(int delta) {

5162

segment_bytes_allocated_ += delta;

5163

Counters::zone_segment_bytes.Set(segment_bytes_allocated_);

5164

}

5165

5166

5167

} } // namespace v8::internal

5168

5169

+#pragma GCC visibility pop

5170

5171

#endif // V8_ZONE_INL_H_

5172

Index: chromium-v8-1.2.14~svn20090716r2483/src/log.cc

5173

===================================================================

5174

--- chromium-v8-1.2.14~svn20090716r2483.orig/src/log.cc

5175

+++ chromium-v8-1.2.14~svn20090716r2483/src/log.cc

5176

@@ -30,16 +30,18 @@

5177

#include "v8.h"

5178

5179

#include "bootstrapper.h"

5180

#include "log.h"

5181

#include "macro-assembler.h"

5182

#include "serialize.h"

5183

#include "string-stream.h"

5184

5185

+#pragma GCC visibility push(hidden)

5186

5187

namespace v8 {

5188

namespace internal {

5189

5190

#ifdef ENABLE_LOGGING_AND_PROFILING

5191

5192

5193

// Sliding state window. Updates counters to keep track of the last

5194

// window of kBufferSize states. This is useful to track where we

5195

@@ -1197,8 +1199,9 @@

5196

if (sliding_state_window_ == NULL) {

5197

sliding_state_window_ = new SlidingStateWindow();

5198

}

5199

#endif

5200

}

5201

5202

5203

} } // namespace v8::internal

5204

+#pragma GCC visibility pop

Older »