| /src/crypto/external/apache2/openssl/dist/external/perl/Text-Template-1.56/t/ |
| safe3.t | 9 unless (eval { require Safe; 1 }) {
10 plan skip_all => 'Safe.pm is required for this test';
18 # Test the OUT feature with safe compartments
34 my $c = Safe->new;
40 SAFE => $c) or die;
45 SAFE => $c) or die;
59 # is never undefined after it is used once if you are using the SAFE
70 my $s = Safe->new;
76 my $r = $o->fill_in(SAFE => $s);
|
| safe.t | 11 unless (eval { require Safe; 1 }) {
12 plan skip_all => 'Safe.pm is required for this test';
32 my $c = Safe->new or die;
43 my $text2 = $template1->fill_in(SAFE => $c);
46 my $text3 = $template2->fill_in(SAFE => $c);
49 # (4) Safe and non-safe fills of different template objects with the
53 # uses package main, while the safe fill uses the secret safe package.
54 # We could alias the secret safe package to be identical to main
[all...] |
| safe2.t | 10 unless (eval { require Safe; 1 }) {
11 plan skip_all => 'Safe.pm is required for this test';
19 my $c = Safe->new or die;
22 $c->reval('$P = "safe root"');
40 # (3) When no package is specified in safe mode, we should use the
41 # default safe root.
42 $text = $t->fill_in(SAFE => $c);
43 is $text, 'package is safe root';
45 # (4) When a package is specified in safe mode, we should use the
46 # default safe root, after aliasing to the specified packag
[all...] |
| /src/crypto/external/bsd/openssl/dist/external/perl/Text-Template-1.56/t/ |
| safe3.t | 9 unless (eval { require Safe; 1 }) {
10 plan skip_all => 'Safe.pm is required for this test';
18 # Test the OUT feature with safe compartments
34 my $c = Safe->new;
40 SAFE => $c) or die;
45 SAFE => $c) or die;
59 # is never undefined after it is used once if you are using the SAFE
70 my $s = Safe->new;
76 my $r = $o->fill_in(SAFE => $s);
|
| safe.t | 11 unless (eval { require Safe; 1 }) {
12 plan skip_all => 'Safe.pm is required for this test';
32 my $c = Safe->new or die;
43 my $text2 = $template1->fill_in(SAFE => $c);
46 my $text3 = $template2->fill_in(SAFE => $c);
49 # (4) Safe and non-safe fills of different template objects with the
53 # uses package main, while the safe fill uses the secret safe package.
54 # We could alias the secret safe package to be identical to main
[all...] |
| safe2.t | 10 unless (eval { require Safe; 1 }) {
11 plan skip_all => 'Safe.pm is required for this test';
19 my $c = Safe->new or die;
22 $c->reval('$P = "safe root"');
40 # (3) When no package is specified in safe mode, we should use the
41 # default safe root.
42 $text = $t->fill_in(SAFE => $c);
43 is $text, 'package is safe root';
45 # (4) When a package is specified in safe mode, we should use the
46 # default safe root, after aliasing to the specified packag
[all...] |
| /src/crypto/external/bsd/openssl.old/dist/external/perl/Text-Template-1.46/t/ |
| 07-safe3.t | 8 eval "use Safe";
25 # Test the OUT feature with safe compartments
41 $c = new Safe;
45 SAFE => $c)
48 SAFE => $c)
64 # is never undefined after it is used once if you are using the SAFE
75 my $s = Safe->new;
80 my $r = $o->fill_in(SAFE => $s);
|
| 04-safe.t | 9 eval "use Safe";
35 $c = new Safe or die;
46 $text2 = $template1->fill_in(SAFE => $c);
48 $text3 = $template2->fill_in(SAFE => $c);
59 # (4) Safe and non-safe fills of different template objects with the
63 # uses package main, while the safe fill uses the secret safe package.
64 # We could alias the secret safe package to be identical to main,
65 # but that wouldn't be safe. If you want the aliasing, you have t
[all...] |
| 05-safe2.t | 9 eval "use Safe";
25 $c = new Safe or die;
28 $c->reval('$P = "safe root"');
47 # (3) When no package is specified in safe mode, we should use the
48 # default safe root.
49 $text = $t->fill_in(SAFE => $c);
50 print +($text eq 'package is safe root' ? '' : 'not '), "ok $n\n";
53 # (4) When a package is specified in safe mode, we should use the
54 # default safe root, after aliasing to the specified package
55 $text = $t->fill_in(SAFE => $c, PACKAGE => Q)
[all...] |
| /src/external/apache2/llvm/dist/llvm/tools/bugpoint/ |
| Miscompilation.cpp | 702 std::unique_ptr<Module> Safe) {
721 auto Result = testMergedProgram(BD, *Optimized, *Safe, Broken);
783 Module *Safe) {
791 // First, if the main function is in the Safe module, we must add a stub to
794 if (Function *oldMain = Safe->getFunction("main"))
818 BasicBlock *BB = BasicBlock::Create(Safe->getContext(), "entry", newMain);
822 ReturnInst::Create(Safe->getContext(), call, BB);
825 // The second nasty issue we must deal with in the JIT is that the Safe
830 // Add the resolver to the Safe module.
832 FunctionCallee resolverFunc = Safe->getOrInsertFunction
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/IPO/ |
| ArgumentPromotion.cpp | 103 /// safe to do so.
521 // This load is safe if any prefix of its operands is safe to load.
525 /// Mark the given indices (ToMark) as safe in the given set of indices
526 /// (Safe). Marking safe usually means adding ToMark to Safe. However, if there
527 /// is already a prefix of Indices in Safe, Indices are implicitely marked safe
529 /// removed from Safe (since they are implicitely safe because of Indices now)
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| GVNHoist.cpp | 329 // Return true when it is safe to hoist a memory load or store U from OldPt
334 // Return true when it is safe to hoist scalar instructions from all blocks in
357 // Check if it is safe to hoist values tracked by CHI in the range
358 // [Begin, End) and accumulate them in Safe.
360 SmallVectorImpl<CHIArg> &Safe);
395 // them Then collect all the instructions which are safe to hoist and see if
696 // from OldBB into NewBB has to be safe on all execution paths.
729 // BBInsn. Hoisting an expression from BBInsn into NewHoistPt has to be safe
755 // In place hoisting is safe.
790 // No side effects: it is safe to hoist
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| LoopAccessAnalysis.h | 64 /// At the moment we will only deem accesses as safe for:
67 /// Safe: tmp = a[i + 1]; OR a[i + 1] = x;
70 /// The latter case is safe because later checks guarantuee that there can't
83 /// Safe distance: 2 x sizeof(a[0]), and 2 x sizeof(b[0]), respectively.
99 // safe.
100 Safe,
118 // read and write of A[i]), LAA will locally deem the dependence "safe"
176 Status(VectorizationSafetyStatus::Safe), RecordDependences(true) {}
196 /// Check whether the dependencies between the accesses are safe.
205 return Status == VectorizationSafetyStatus::Safe;
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Vectorize/ |
| LoadStoreVectorizer.cpp | 440 bool Safe = false;
453 Safe = true;
456 // the same LHS operand, we can guarantee that the transformation is safe
472 if (!Safe && OpA && OpA->getOpcode() == Instruction::Add &&
485 Safe = true;
492 Safe = true;
506 Safe = true;
516 if (!Safe) {
|
| /src/external/gpl3/gdb/dist/gnulib/import/extra/ |
| gitlog-to-changelog | 326 eval 'use Safe';
327 my $s = new Safe;
|
| /src/external/gpl3/gdb.old/dist/gnulib/import/extra/ |
| gitlog-to-changelog | 326 eval 'use Safe';
327 my $s = new Safe;
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/ |
| SafeStack.cpp | 1 //===- SafeStack.cpp - Safe Stack Insertion -------------------------------===//
9 // This pass splits the stack into the safe stack (kept as-is for LLVM backend)
77 #define DEBUG_TYPE "safe-stack"
95 /// access safe stack pointer.
101 static cl::opt<bool> ClColoring("safe-stack-coloring",
102 cl::desc("enable safe stack coloring"),
125 /// The SafeStack pass splits the stack of each function into the safe
126 /// stack, which is only accessed through memory safe dereferences (as
129 /// be safe.
247 bool Safe = AllocaRange.contains(AccessRange)
[all...] |
| MachineLICM.cpp | 163 // If a MBB does not dominate loop exiting blocks then it may not safe
459 // safe to hoist.
483 // register, then this is not safe. Two defs is indicated by setting a
575 bool Safe = true;
584 // not safe to hoist.
585 Safe = false;
589 if (Safe)
612 /// safe to hoist, this instruction is called to do the dirty work.
642 /// may not be safe to hoist.
957 /// e.g. If the instruction is a call, then it's obviously not safe to hoist it
[all...] |
| /src/external/gpl3/gcc.old/dist/libphobos/libdruntime/core/ |
| lifetime.d | 13 T* emplace(T)(T* chunk) @safe pure nothrow
55 `T` is `@safe`.
94 This function is `@safe` if the corresponding constructor of `T` is `@safe`.
138 @safe unittest
140 () @safe {
144 @safe this(int x) { this.x = x; }
165 @safe unittest
172 @safe auto getI() { return i; }
197 This function can be `@trusted` if the corresponding constructor of `T` is `@safe`
[all...] |
| /src/external/gpl3/gcc.old/dist/libphobos/src/std/ |
| traits.d | 219 @safe unittest
236 @safe unittest
253 @safe unittest
270 @safe unittest
288 @safe unittest
307 @safe unittest
325 @safe unittest
333 @safe unittest
374 @safe unittest
384 @safe unittes
[all...] |
| /src/crypto/external/bsd/openssl/dist/external/perl/Text-Template-1.56/lib/Text/ |
| Template.pm | 307 my $fi_safe = _param('safe', %fi_a);
358 # is the default one available in the safe compartment.
652 # Evaluate program fragments in Safe compartment with restricted permissions
653 $text = $template->fill_in(SAFE => $compartment, ...);
1039 C<BROKEN_ARG>, C<FILENAME>, C<SAFE>, C<HASH>, C<OUTPUT>, and C<DELIMITERS>.
1085 This is not very safe. The reason this isn't as safe is that if you
1091 safe.)
1095 are safe.
1097 But if you use the C<PACKAGE> option, you will probably be safe eve
[all...] |
| /src/crypto/external/bsd/openssl.old/dist/external/perl/Text-Template-1.46/lib/Text/ |
| Template.pm | 253 my $fi_safe = _param('safe', %fi_a);
290 # is the default one available in the safe compartment.
525 # Evaluate program fragments in Safe compartment with restricted permissions
526 $text = $template->fill_in(SAFE => $compartment, ...);
904 C<BROKEN_ARG>, C<SAFE>, C<HASH>, C<OUTPUT>, and C<DELIMITERS>.
951 This is not very safe. The reason this isn't as safe is that if you
957 safe.)
961 are safe.
963 But if you use the C<PACKAGE> option, you will probably be safe eve
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| LoopAccessAnalysis.cpp | 334 // the accesses are safe.
1252 return VectorizationSafetyStatus::Safe;
1597 // not safe to do vectorization.
1606 // Unsafe if the minimum distance needed is greater than max safe distance.
1624 // This case is currently unsafe according to the max safe distance. If we
1625 // analyze the two accesses on array B, the max safe dependence distance
1834 // the flag. Therefore, it is safe to ignore this read from memory.
2010 // other reads in this loop then is it safe to vectorize.
2207 OS.indent(Depth) << "Memory dependences are safe";
|
| ValueTracking.cpp | 111 /// If true, it is safe to use metadata during simplification.
4574 // It's safe to hoist if the denominator is not 0 or -1.
4577 // At this point we know that the denominator is -1. It is safe to hoist as
4913 return true; // Can't tell, just return true to be safe
4917 bool Safe = llvm::all_of(ShiftAmounts, [](Constant *C) {
4921 return !Safe;
|
| /src/crypto/external/apache2/openssl/dist/external/perl/Text-Template-1.56/lib/Text/ |
| Template.pm | 307 my $fi_safe = _param('safe', %fi_a);
358 # is the default one available in the safe compartment.
652 # Evaluate program fragments in Safe compartment with restricted permissions
653 $text = $template->fill_in(SAFE => $compartment, ...);
1039 C<BROKEN_ARG>, C<FILENAME>, C<SAFE>, C<HASH>, C<OUTPUT>, and C<DELIMITERS>.
1085 This is not very safe. The reason this isn't as safe is that if you
1091 safe.)
1095 are safe.
1097 But if you use the C<PACKAGE> option, you will probably be safe eve
[all...] |
